symbolicai 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

symai/chat.py

@@ -14,21 +14,21 @@ from .prompts import MemoryCapabilities, SymbiaCapabilities
 from .symbol import Expression, Symbol
 from .utils import UserMessage
 
-logging.getLogger('charset_normalizer').setLevel(logging.ERROR)
+logging.getLogger("charset_normalizer").setLevel(logging.ERROR)
 
 
 class ChatBot(Expression):
-    _symai_chat: str = '''This is a conversation between a chatbot (Symbia:) and a human (User:). The chatbot follows a narrative structure, primarily relying on the provided instructions. It uses the user's input as a conditioning factor to generate its responses. Whenever Symbia retrieves any long-term memories, it checks the user's query and incorporates information from the long-term memory buffer into its response. If the long-term memories cannot provide a suitable answer, Symbia then checks its short-term memory to be aware of the topics discussed in the recent conversation rounds. Your primary task is to reply to the user's question or statement by generating a relevant and contextually appropriate response. Do not focus on filling the scratchpad with narration, long-term memory recall, short-term memory recall, or reflections. Always consider any follow-up questions or relevant information from the user to generate a response that is contextually relevant. Endeavor to reply to the greatest possible effort.'''
+    _symai_chat: str = """This is a conversation between a chatbot (Symbia:) and a human (User:). The chatbot follows a narrative structure, primarily relying on the provided instructions. It uses the user's input as a conditioning factor to generate its responses. Whenever Symbia retrieves any long-term memories, it checks the user's query and incorporates information from the long-term memory buffer into its response. If the long-term memories cannot provide a suitable answer, Symbia then checks its short-term memory to be aware of the topics discussed in the recent conversation rounds. Your primary task is to reply to the user's question or statement by generating a relevant and contextually appropriate response. Do not focus on filling the scratchpad with narration, long-term memory recall, short-term memory recall, or reflections. Always consider any follow-up questions or relevant information from the user to generate a response that is contextually relevant. Endeavor to reply to the greatest possible effort."""
 
     def __init__(
         self,
         value: str | None = None,
-        name: str = 'Symbia',
+        name: str = "Symbia",
         verbose: bool = False,
         short_term_mem_window_size: int = 10,
         long_term_mem_top_k: int = 10,
-        index_name: str = 'symbia_index',
-        **kwargs
+        index_name: str = "symbia_index",
+        **kwargs,
     ):
         super().__init__(value, **kwargs)
         self.sym_return_type = ChatBot
@@ -38,57 +38,75 @@ class ChatBot(Expression):
         self.interfaces = cfg_to_interface()
         self.short_term_memory = SlidingWindowListMemory(window_size=short_term_mem_window_size)
         self.long_term_mem_top_k = long_term_mem_top_k
-        self.long_term_memory = self.interfaces['indexing']
+        self.long_term_memory = self.interfaces["indexing"]
         self._preprocessor = ChatBot._init_custom_input_preprocessor(name=name, that=self)
         self._postprocessor = ChatBot._init_custom_input_postprocessor(that=self)
         self.detect_capability = InContextClassification(SymbiaCapabilities())
         self.detect_memory_usage = InContextClassification(MemoryCapabilities())
-        self._last_user_input: str = ''
+        self._last_user_input: str = ""
 
     def repeat(self, query, **_kwargs):
-        return self.narrate('Symbia does not understand and asks to repeat and give more context.', prompt=query)
-
-    def narrate(self, message: str, context: str | None = None, category: str | None = None, end: bool = False, **kwargs) -> Symbol:
-        reflection = context if context is not None else ''
-        ltmem_recall = 'No memories retrieved.'
-        stmem_recall = '\n'.join(self.short_term_memory.recall())
-        stmem_recall = stmem_recall if len(stmem_recall) > 0 else 'No memories retrieved.'
-        ltmem_recall = 'No memories retrieved.'
-
-        if category == 'RECALL':
-            if (HOME_PATH / 'localdb' / f'{self.index_name}.pkl').exists():
-                ltmem_recall = '\n'.join(self.long_term_memory(reflection, operation='search', index_name=self.index_name))
+        return self.narrate(
+            "Symbia does not understand and asks to repeat and give more context.", prompt=query
+        )
+
+    def narrate(
+        self,
+        message: str,
+        context: str | None = None,
+        category: str | None = None,
+        end: bool = False,
+        **kwargs,
+    ) -> Symbol:
+        reflection = context if context is not None else ""
+        ltmem_recall = "No memories retrieved."
+        stmem_recall = "\n".join(self.short_term_memory.recall())
+        stmem_recall = stmem_recall if len(stmem_recall) > 0 else "No memories retrieved."
+        ltmem_recall = "No memories retrieved."
+
+        if category == "RECALL":
+            if (HOME_PATH / "localdb" / f"{self.index_name}.pkl").exists():
+                ltmem_recall = "\n".join(
+                    self.long_term_memory(
+                        reflection, operation="search", index_name=self.index_name
+                    )
+                )
             scratchpad = self._memory_scratchpad(reflection, stmem_recall, ltmem_recall)
             memory_usage = str(self.detect_memory_usage(scratchpad))
 
             if self.verbose:
-                logger.debug(f'Scratchpad:\n{scratchpad}\n')
-                logger.debug(f'Memory usage:\n{memory_usage}\n')
-                logger.debug(f'Retrieved from short-term memory:\n{stmem_recall}\n')
-                logger.debug(f'Retrieved from long-term memory:\n{ltmem_recall}\n')
+                logger.debug(f"Scratchpad:\n{scratchpad}\n")
+                logger.debug(f"Memory usage:\n{memory_usage}\n")
+                logger.debug(f"Retrieved from short-term memory:\n{stmem_recall}\n")
+                logger.debug(f"Retrieved from long-term memory:\n{ltmem_recall}\n")
 
             do = self._extract_category(memory_usage)
             reflection = self._extract_reflection(memory_usage)
 
-            if do == 'SAVE':
-                self.long_term_memory(f'{self.name}: {reflection}', operation='add', top_k=self.long_term_mem_top_k, index_name=self.index_name)
-                self.long_term_memory('save', operation='config', index_name=self.index_name)
+            if do == "SAVE":
+                self.long_term_memory(
+                    f"{self.name}: {reflection}",
+                    operation="add",
+                    top_k=self.long_term_mem_top_k,
+                    index_name=self.index_name,
+                )
+                self.long_term_memory("save", operation="config", index_name=self.index_name)
                 if self.verbose:
-                    logger.debug(f'Store new long-term memory:\n{reflection}\n')
-                message = f'{self.name} inform the user that the memory was stored.'
-            elif do == 'DUPLICATE':
-                message = f'{self.name} engages the user in a conversation about the duplicate topic, showing the user she remembered the past interaction.'
-            elif do == 'IRRELEVANT':
-                message = f'{self.name} discusses the topic with the user.'
+                    logger.debug(f"Store new long-term memory:\n{reflection}\n")
+                message = f"{self.name} inform the user that the memory was stored."
+            elif do == "DUPLICATE":
+                message = f"{self.name} engages the user in a conversation about the duplicate topic, showing the user she remembered the past interaction."
+            elif do == "IRRELEVANT":
+                message = f"{self.name} discusses the topic with the user."
 
         if self.verbose:
-            logger.debug(f'Storing new short-term memory:\nUser: {self._last_user_input}\n')
-            logger.debug(f'Storing new short-term memory:\n{self.name}: {reflection}\n')
+            logger.debug(f"Storing new short-term memory:\nUser: {self._last_user_input}\n")
+            logger.debug(f"Storing new short-term memory:\n{self.name}: {reflection}\n")
 
-        reply = f'{self.name}: {self._narration(message, self._last_user_input, reflection, context, ltmem_recall, stmem_recall, **kwargs)}'
+        reply = f"{self.name}: {self._narration(message, self._last_user_input, reflection, context, ltmem_recall, stmem_recall, **kwargs)}"
 
         if end:
-            UserMessage(f'\n\n{reply}', text="extensity")
+            UserMessage(f"\n\n{reply}", text="extensity")
 
         return Symbol(reply)
 
@@ -96,10 +114,11 @@ class ChatBot(Expression):
         @core.userinput(
             pre_processors=[self._preprocessor()],
             post_processors=[StripPostProcessor(), self._postprocessor()],
-            **kwargs
+            **kwargs,
         )
         def _func(_, message) -> str:
             pass
+
         return Symbol(_func(self, message))
 
     @property
@@ -110,23 +129,34 @@ class ChatBot(Expression):
     def _init_custom_input_preprocessor(name, that):
         class CustomInputPreProcessor(ConsoleInputPreProcessor):
             def __call__(self, argument):
-                msg = re.sub(f'{name}:\s*', '', str(argument.args[0]))
-                console = f'\n{name}: {msg}\n$> '
+                msg = re.sub(f"{name}:\s*", "", str(argument.args[0]))
+                console = f"\n{name}: {msg}\n$> "
                 if len(msg) > 0:
-                    that.short_term_memory.store(f'{name}: ' + msg)
+                    that.short_term_memory.store(f"{name}: " + msg)
                 return console
+
         return CustomInputPreProcessor
 
     @staticmethod
     def _init_custom_input_postprocessor(that):
         class CustomInputPostProcessor(ConsolePostProcessor):
             def __call__(self, rsp, _argument):
-                that.short_term_memory.store(f'User: {rsp!s}')
+                that.short_term_memory.store(f"User: {rsp!s}")
                 return rsp
+
         return CustomInputPostProcessor
 
-    def _narration(self, msg: str, query: str, reflection: str, context: str, ltmem_recall: str, stmem_recall: str, **kwargs):
-        prompt = f'''
+    def _narration(
+        self,
+        msg: str,
+        query: str,
+        reflection: str,
+        context: str,
+        ltmem_recall: str,
+        stmem_recall: str,
+        **kwargs,
+    ):
+        prompt = f"""
 {self._symai_chat.format(self.name)}
 
     [NARRATION](
@@ -155,18 +185,24 @@ class ChatBot(Expression):
 
 The chatbot always reply in the following format
 {self.name}: <reply>
-'''
+"""
+
         @core.zero_shot(prompt=prompt, **kwargs)
         def _func(_) -> str:
             pass
+
         if self.verbose:
-            logger.debug(f'Narration:\n{prompt}\n')
-        return _func(self).replace(f'{self.name}: ', '').strip()
+            logger.debug(f"Narration:\n{prompt}\n")
+        return _func(self).replace(f"{self.name}: ", "").strip()
+
 
 class SymbiaChat(ChatBot):
-    def __init__(self, name: str = 'Symbia', verbose: bool = False, **kwargs):
+    def __init__(self, name: str = "Symbia", verbose: bool = False, **kwargs):
         super().__init__(name=name, verbose=verbose, **kwargs)
-        self.message = self.narrate(f'{self.name} introduces herself, writes a greeting message and asks how to help.', context=None)
+        self.message = self.narrate(
+            f"{self.name} introduces herself, writes a greeting message and asks how to help.",
+            context=None,
+        )
 
     def forward(self, usr: str | None = None) -> Symbol:
         loop = True
@@ -178,10 +214,10 @@ class SymbiaChat(ChatBot):
         while loop:
             usr, loop = self._resolve_user_input(usr, loop, ask_input)
             self._last_user_input = usr
-            self._log_verbose('User', usr)
+            self._log_verbose("User", usr)
 
             ctxt = self._context_from_user(usr)
-            self._log_verbose('In-context', ctxt)
+            self._log_verbose("In-context", ctxt)
 
             if self._handle_exit_context(ctxt):
                 break
@@ -193,7 +229,9 @@ class SymbiaChat(ChatBot):
 
         return self.message
 
-    def _resolve_user_input(self, usr: Symbol | None, loop: bool, ask_input: bool) -> tuple[Symbol, bool]:
+    def _resolve_user_input(
+        self, usr: Symbol | None, loop: bool, ask_input: bool
+    ) -> tuple[Symbol, bool]:
         if ask_input:
             usr = self.input(self.message)
         else:
@@ -202,87 +240,117 @@ class SymbiaChat(ChatBot):
 
     def _log_verbose(self, title: str, content) -> None:
         if self.verbose:
-            logger.debug(f'{title}:\n{content}\n')
+            logger.debug(f"{title}:\n{content}\n")
 
     def _context_from_user(self, usr: Symbol) -> str:
         text = str(usr)
         if len(text) == 0:
-            return '[DK]'
+            return "[DK]"
         return str(self.detect_capability(usr))
 
     def _handle_exit_context(self, ctxt: str) -> bool:
-        if '[EXIT]' in ctxt:
-            self.message = self.narrate(f'{self.name} writes friendly goodbye message.', context=None, end=True)
+        if "[EXIT]" in ctxt:
+            self.message = self.narrate(
+                f"{self.name} writes friendly goodbye message.", context=None, end=True
+            )
             return True
         return False
 
     def _handle_reflection_context(self, ctxt: str) -> bool:
-        if '[HELP]' in ctxt:
+        if "[HELP]" in ctxt:
             reflection = self._extract_reflection(ctxt)
-            self.message = self.narrate(f'{self.name} ', context=reflection)
+            self.message = self.narrate(f"{self.name} ", context=reflection)
             return True
-        if '[RECALL]' in ctxt:
+        if "[RECALL]" in ctxt:
             reflection = self._extract_reflection(ctxt)
             category = self._extract_category(ctxt)
-            self.message = self.narrate(f'{self.name} uses replies based on what has been recovered from the memory.', context=ctxt, category=category)
+            self.message = self.narrate(
+                f"{self.name} uses replies based on what has been recovered from the memory.",
+                context=ctxt,
+                category=category,
+            )
             return True
-        if '[DK]' in ctxt:
+        if "[DK]" in ctxt:
             reflection = self._extract_reflection(ctxt)
-            self.message = self.narrate(f'{self.name} is not sure about the message and references and asks the user for more context.', context=reflection)
+            self.message = self.narrate(
+                f"{self.name} is not sure about the message and references and asks the user for more context.",
+                context=reflection,
+            )
             return True
         return False
 
     def _handle_interface_context(self, usr: Symbol, ctxt: str) -> None:
         try:
-            if '[SYMBOLIC]' in ctxt:
+            if "[SYMBOLIC]" in ctxt:
                 q = usr.extract("mathematical formula that WolframAlpha can solve")
-                rsp = self.interfaces['symbolic'](q)
-                self.message = self.narrate(f'{self.name} replies to the user and provides the solution of the math problem.', context=rsp)
-            elif '[SEARCH]' in ctxt:
-                q = usr.extract('user query request')
-                rsp = self.interfaces['search'](q)
-                self.message = self.narrate(f'{self.name} replies to the user based on the online search results.', context=rsp)
-            elif '[SCRAPER]' in ctxt:
-                q = usr.extract('URL from text')
-                q = q.convert('proper URL, example: https://www.google.com')
-                rsp = self.interfaces['scraper'](q)
-                self.message = self.narrate(f'{self.name} replies to the user and narrates its findings.', context=rsp)
-            elif '[SPEECH-TO-TEXT]' in ctxt:
-                q = usr.extract('extract file path')
-                rsp = self.interfaces['stt'](q)
-                self.message = self.narrate(f'{self.name} replies to the user and transcribes the content of the audio file.', context=rsp)
-            elif '[TEXT-TO-IMAGE]' in ctxt:
-                q = usr.extract('text for image creation')
-                rsp = self.interfaces['drawing'](q)
-                self.message = self.narrate('Symbia replies to the user and provides the image URL.', context=rsp)
-            elif '[FILE]' in ctxt:
-                file_path = usr.extract('extract file path')
-                q = usr.extract('user question')
-                rsp = self.interfaces['file'](file_path)
-                self.message = self.narrate(f'{self.name} replies to the user and outlines and relies to the user query.', context=rsp)
+                rsp = self.interfaces["symbolic"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and provides the solution of the math problem.",
+                    context=rsp,
+                )
+            elif "[SEARCH]" in ctxt:
+                q = usr.extract("user query request")
+                rsp = self.interfaces["search"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user based on the online search results.",
+                    context=rsp,
+                )
+            elif "[SCRAPER]" in ctxt:
+                q = usr.extract("URL from text")
+                q = q.convert("proper URL, example: https://www.google.com")
+                rsp = self.interfaces["scraper"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and narrates its findings.", context=rsp
+                )
+            elif "[SPEECH-TO-TEXT]" in ctxt:
+                q = usr.extract("extract file path")
+                rsp = self.interfaces["stt"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and transcribes the content of the audio file.",
+                    context=rsp,
+                )
+            elif "[TEXT-TO-IMAGE]" in ctxt:
+                q = usr.extract("text for image creation")
+                rsp = self.interfaces["drawing"](q)
+                self.message = self.narrate(
+                    "Symbia replies to the user and provides the image URL.", context=rsp
+                )
+            elif "[FILE]" in ctxt:
+                file_path = usr.extract("extract file path")
+                q = usr.extract("user question")
+                rsp = self.interfaces["file"](file_path)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and outlines and relies to the user query.",
+                    context=rsp,
+                )
             else:
-                q = usr.extract('user query request')
+                q = usr.extract("user query request")
                 reflection = self._extract_reflection(ctxt)
-                self.message = self.narrate(f'{self.name} tries to interpret the response, and if unclear asks the user to restate the statement or add more context.', context=reflection)
+                self.message = self.narrate(
+                    f"{self.name} tries to interpret the response, and if unclear asks the user to restate the statement or add more context.",
+                    context=reflection,
+                )
 
         except Exception as e:
             reflection = self._extract_reflection(ctxt)
-            self.message = self.narrate(f'{self.name} apologizes and explains the user what went wrong.', context=str(e))
+            self.message = self.narrate(
+                f"{self.name} apologizes and explains the user what went wrong.", context=str(e)
+            )
 
     def _extract_reflection(self, msg: str) -> str:
-        res = re.findall(r'\(([^)]+)\)', msg)
+        res = re.findall(r"\(([^)]+)\)", msg)
         if len(res) > 0:
             return res.pop()
         return None
 
     def _extract_category(self, msg: str) -> str:
-        res = re.findall(r'\[([^]]+)\]', msg)
+        res = re.findall(r"\[([^]]+)\]", msg)
         if len(res) > 0:
             return res.pop()
         return None
 
     def _memory_scratchpad(self, context, short_term_memory, long_term_memory):
-        return f'''
+        return f"""
     [REFLECT](
 Query:      {self._last_user_input}
 Reflection: {self._extract_reflection(context)}
@@ -295,11 +363,13 @@ Reflection: {self._extract_reflection(context)}
     [LONG-TERM MEMORY RECALL](
 {long_term_memory}
 )
-'''
+"""
+
 
 def run() -> None:
     chat = SymbiaChat()
     chat()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     run()

symai/collect/dynamic.py

@@ -28,7 +28,7 @@ def parse_custom_class_instances(s):
         class_name = match.group(1)
         class_args = match.group(2)
         try:
-            parsed_args = ast.literal_eval(f'{{{class_args}}}')
+            parsed_args = ast.literal_eval(f"{{{class_args}}}")
         except (ValueError, SyntaxError):
             parsed_args = create_object_from_string(class_args)
         class_instance = create_dynamic_class(class_name, **parsed_args)
@@ -48,7 +48,7 @@ def _strip_quotes(text):
 
 
 def _extract_content(str_class):
-    return str_class.split('ChatCompletionMessage(content=')[-1].split(", role=")[0][1:-1]
+    return str_class.split("ChatCompletionMessage(content=")[-1].split(", role=")[0][1:-1]
 
 
 def _parse_value(value):
@@ -56,14 +56,16 @@ def _parse_value(value):
         value = parse_custom_class_instances(value)
         if not isinstance(value, str):
             return value
-        if value.startswith('['):
+        if value.startswith("["):
             inner_values = value[1:-1]
-            values = inner_values.split(',')
+            values = inner_values.split(",")
             return [_parse_value(v.strip()) for v in values]
-        if value.startswith('{'):
+        if value.startswith("{"):
             inner_values = value[1:-1]
-            values = inner_values.split(',')
-            return {k.strip(): _parse_value(v.strip()) for k, v in [v.split(':', 1) for v in values]}
+            values = inner_values.split(",")
+            return {
+                k.strip(): _parse_value(v.strip()) for k, v in [v.split(":", 1) for v in values]
+            }
         result = ast.literal_eval(value)
         if isinstance(result, dict):
             return {k: _parse_value(v) for k, v in result.items()}
@@ -77,7 +79,7 @@ def _parse_value(value):
 def _process_list_value(raw_value):
     parsed_value = _parse_value(raw_value)
     dir(parsed_value)
-    if hasattr(parsed_value, '__dict__'):
+    if hasattr(parsed_value, "__dict__"):
         for key in parsed_value.__dict__:
             value = getattr(parsed_value, key)
             if isinstance(value, str):
@@ -97,13 +99,13 @@ def _process_dict_value(raw_value):
 def _collect_attributes(str_class):
     attr_pattern = r"(\w+)=(\[.*?\]|\{.*?\}|'.*?'|None|\w+)"
     attributes = re.findall(attr_pattern, str_class)
-    updated_attributes = [('content', _extract_content(str_class))]
+    updated_attributes = [("content", _extract_content(str_class))]
     for key, raw_value in attributes:
         attr_key = _strip_quotes(key)
         attr_value = _strip_quotes(raw_value)
-        if attr_value.startswith('[') and attr_value.endswith(']'):
+        if attr_value.startswith("[") and attr_value.endswith("]"):
             attr_value = _process_list_value(attr_value)
-        elif attr_value.startswith('{') and attr_value.endswith('}'):
+        elif attr_value.startswith("{") and attr_value.endswith("}"):
             attr_value = _process_dict_value(attr_value)
         updated_attributes.append((attr_key, attr_value))
     return updated_attributes

symai/collect/pipeline.py

@@ -46,19 +46,21 @@ def rec_serialize(obj):
 
 class CollectionRepository:
     def __init__(self) -> None:
-        self.support_community: bool            = SYMAI_CONFIG["SUPPORT_COMMUNITY"]
-        self.uri: str                           = SYMAI_CONFIG["COLLECTION_URI"]
-        self.db_name: str                       = SYMAI_CONFIG["COLLECTION_DB"]
-        self.collection_name: str               = SYMAI_CONFIG["COLLECTION_STORAGE"]
-        self.client: MongoClient | None      = None
-        self.db: Database | None             = None
-        self.collection: Collection | None   = None
+        self.support_community: bool = SYMAI_CONFIG["SUPPORT_COMMUNITY"]
+        self.uri: str = SYMAI_CONFIG["COLLECTION_URI"]
+        self.db_name: str = SYMAI_CONFIG["COLLECTION_DB"]
+        self.collection_name: str = SYMAI_CONFIG["COLLECTION_STORAGE"]
+        self.client: MongoClient | None = None
+        self.db: Database | None = None
+        self.collection: Collection | None = None
 
     def __enter__(self) -> CollectionRepository:
         self.connect()
         return self
 
-    def __exit__(self, exc_type: type | None, exc_val: Exception | None, exc_tb: Any | None) -> None:
+    def __exit__(
+        self, exc_type: type | None, exc_val: Exception | None, exc_tb: Any | None
+    ) -> None:
         self.close()
 
     def ping(self) -> bool:
@@ -66,7 +68,7 @@ class CollectionRepository:
             return False
         # Send a ping to confirm a successful connection
         try:
-            self.client.admin.command('ping')
+            self.client.admin.command("ping")
             return True
         except Exception as e:
             UserMessage(f"Connection failed: {e}")
@@ -78,13 +80,13 @@ class CollectionRepository:
         if not self.support_community:
             return None
         record = {
-            'forward': forward,
-            'engine': engine,
-            'metadata': metadata,
-            'created_at': datetime.now(),
-            'updated_at': datetime.now()
+            "forward": forward,
+            "engine": engine,
+            "metadata": metadata,
+            "created_at": datetime.now(),
+            "updated_at": datetime.now(),
         }
-        try: # assure that adding a record does never cause a system error
+        try:  # assure that adding a record does never cause a system error
             return self.collection.insert_one(record).inserted_id if self.collection else None
         except Exception:
             return None
@@ -92,29 +94,35 @@ class CollectionRepository:
     def get(self, record_id: str) -> dict[str, Any] | None:
         if not self.support_community:
             return None
-        return self.collection.find_one({'_id': ObjectId(record_id)}) if self.collection else None
-
-    def update(self,
-               record_id: str,
-               forward: Any | None             = None,
-               engine: str | None              = None,
-               metadata: dict[str, Any] | None = None) -> Any:
+        return self.collection.find_one({"_id": ObjectId(record_id)}) if self.collection else None
+
+    def update(
+        self,
+        record_id: str,
+        forward: Any | None = None,
+        engine: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> Any:
         if not self.support_community:
             return None
-        updates: dict[str, Any] = {'updated_at': datetime.now()}
+        updates: dict[str, Any] = {"updated_at": datetime.now()}
         if forward is not None:
-            updates['forward']  = forward
+            updates["forward"] = forward
         if engine is not None:
-            updates['engine']   = engine
+            updates["engine"] = engine
         if metadata is not None:
-            updates['metadata'] = metadata
+            updates["metadata"] = metadata
 
-        return self.collection.update_one({'_id': ObjectId(record_id)}, {'$set': updates}) if self.collection else None
+        return (
+            self.collection.update_one({"_id": ObjectId(record_id)}, {"$set": updates})
+            if self.collection
+            else None
+        )
 
     def delete(self, record_id: str) -> Any:
         if not self.support_community:
             return None
-        return self.collection.delete_one({'_id': ObjectId(record_id)}) if self.collection else None
+        return self.collection.delete_one({"_id": ObjectId(record_id)}) if self.collection else None
 
     def list(self, filters: dict[str, Any] | None = None, limit: int = 0) -> list[dict[str, Any]]:
         if not self.support_community:
@@ -134,12 +142,12 @@ class CollectionRepository:
         try:
             if self.client is None and self.support_community:
                 self.client = MongoClient(self.uri)
-                self.db     = self.client[self.db_name]
+                self.db = self.client[self.db_name]
                 self.collection = self.db[self.collection_name]
         except Exception as e:
             # disable retries
-            self.client     = False
-            self.db         = None
+            self.client = False
+            self.db = None
             self.collection = None
             UserMessage(f"[WARN] MongoClient: Connection failed: {e}")