MemoryOS 0.1.13__py3-none-any.whl → 0.2.1__py3-none-any.whl

memos/mem_reader/simple_struct.py

@@ -16,6 +16,7 @@ from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemory
 from memos.parsers.factory import ParserFactory
 from memos.templates.mem_reader_prompts import (
     SIMPLE_STRUCT_DOC_READER_PROMPT,
+    SIMPLE_STRUCT_MEM_READER_EXAMPLE,
     SIMPLE_STRUCT_MEM_READER_PROMPT,
 )
 
@@ -39,11 +40,11 @@ class SimpleStructMemReader(BaseMemReader, ABC):
         self.chunker = ChunkerFactory.from_config(config.chunker)
 
     def _process_chat_data(self, scene_data_info, info):
-        prompt = (
-            SIMPLE_STRUCT_MEM_READER_PROMPT.replace("${user_a}", "user")
-            .replace("${user_b}", "assistant")
-            .replace("${conversation}", "\n".join(scene_data_info))
+        prompt = SIMPLE_STRUCT_MEM_READER_PROMPT.replace(
+            "${conversation}", "\n".join(scene_data_info)
         )
+        if self.config.remove_prompt_example:
+            prompt = prompt.replace(SIMPLE_STRUCT_MEM_READER_EXAMPLE, "")
 
         messages = [{"role": "user", "content": prompt}]
 
@@ -207,15 +208,15 @@ class SimpleStructMemReader(BaseMemReader, ABC):
         for i, chunk_res in enumerate(processed_chunks):
             if chunk_res:
                 node_i = TextualMemoryItem(
-                    memory=chunk_res["summary"],
+                    memory=chunk_res["value"],
                     metadata=TreeNodeTextualMemoryMetadata(
                         user_id=info.get("user_id"),
                         session_id=info.get("session_id"),
                         memory_type="LongTermMemory",
                         status="activated",
                         tags=chunk_res["tags"],
-                        key="",
-                        embedding=self.embedder.embed([chunk_res["summary"]])[0],
+                        key=chunk_res["key"],
+                        embedding=self.embedder.embed([chunk_res["value"]])[0],
                         usage=[],
                         sources=[f"{scene_data_info['file']}_{i}"],
                         background="",
@@ -228,7 +229,11 @@ class SimpleStructMemReader(BaseMemReader, ABC):
 
     def parse_json_result(self, response_text):
         try:
-            response_text = response_text.replace("```", "").replace("json", "")
+            json_start = response_text.find("{")
+            response_text = response_text[json_start:]
+            response_text = response_text.replace("```", "").strip()
+            if response_text[-1] != "}":
+                response_text += "}"
             response_json = json.loads(response_text)
             return response_json
         except json.JSONDecodeError as e:

memos/mem_scheduler/base_scheduler.py

@@ -2,61 +2,283 @@ import queue
 import threading
 import time
 
-from abc import abstractmethod
-from queue import Queue
+from datetime import datetime
+from pathlib import Path
 
-from memos.configs.mem_scheduler import BaseSchedulerConfig
+from memos.configs.mem_scheduler import AuthConfig, BaseSchedulerConfig
 from memos.llms.base import BaseLLM
 from memos.log import get_logger
+from memos.mem_cube.general import GeneralMemCube
 from memos.mem_scheduler.modules.dispatcher import SchedulerDispatcher
+from memos.mem_scheduler.modules.misc import AutoDroppingQueue as Queue
+from memos.mem_scheduler.modules.monitor import SchedulerMonitor
+from memos.mem_scheduler.modules.rabbitmq_service import RabbitMQSchedulerModule
 from memos.mem_scheduler.modules.redis_service import RedisSchedulerModule
+from memos.mem_scheduler.modules.retriever import SchedulerRetriever
 from memos.mem_scheduler.modules.schemas import (
+    ACTIVATION_MEMORY_TYPE,
+    ADD_LABEL,
+    DEFAULT_ACT_MEM_DUMP_PATH,
     DEFAULT_CONSUME_INTERVAL_SECONDS,
     DEFAULT_THREAD__POOL_MAX_WORKERS,
+    LONG_TERM_MEMORY_TYPE,
+    NOT_INITIALIZED,
+    PARAMETER_MEMORY_TYPE,
+    QUERY_LABEL,
+    TEXT_MEMORY_TYPE,
+    USER_INPUT_TYPE,
+    WORKING_MEMORY_TYPE,
     ScheduleLogForWebItem,
     ScheduleMessageItem,
+    TreeTextMemory_SEARCH_METHOD,
 )
+from memos.mem_scheduler.utils import transform_name_to_key
+from memos.memories.activation.kv import KVCacheMemory
+from memos.memories.activation.vllmkv import VLLMKVCacheItem, VLLMKVCacheMemory
+from memos.memories.textual.tree import TextualMemoryItem, TreeTextMemory
+from memos.templates.mem_scheduler_prompts import MEMORY_ASSEMBLY_TEMPLATE
 
 
 logger = get_logger(__name__)
 
 
-class BaseScheduler(RedisSchedulerModule):
+class BaseScheduler(RabbitMQSchedulerModule, RedisSchedulerModule):
     """Base class for all mem_scheduler."""
 
     def __init__(self, config: BaseSchedulerConfig):
         """Initialize the scheduler with the given configuration."""
         super().__init__()
         self.config = config
+
+        # hyper-parameters
+        self.top_k = self.config.get("top_k", 5)
+        self.context_window_size = self.config.get("context_window_size", 5)
+        self.enable_act_memory_update = self.config.get("enable_act_memory_update", False)
+        self.act_mem_dump_path = self.config.get("act_mem_dump_path", DEFAULT_ACT_MEM_DUMP_PATH)
+        self.search_method = TreeTextMemory_SEARCH_METHOD
+
+        self.enable_parallel_dispatch = self.config.get("enable_parallel_dispatch", False)
         self.max_workers = self.config.get(
             "thread_pool_max_workers", DEFAULT_THREAD__POOL_MAX_WORKERS
         )
-        self.retriever = None
-        self.monitor = None
-        self.enable_parallel_dispatch = self.config.get("enable_parallel_dispatch", False)
+
+        self.retriever: SchedulerRetriever | None = None
+        self.monitor: SchedulerMonitor | None = None
+
         self.dispatcher = SchedulerDispatcher(
             max_workers=self.max_workers, enable_parallel_dispatch=self.enable_parallel_dispatch
         )
 
-        # message queue
-        self.memos_message_queue: Queue[ScheduleMessageItem] = Queue()
-        self._web_log_message_queue: Queue[ScheduleLogForWebItem] = Queue()
+        # internal message queue
+        self.max_internal_messae_queue_size = 100
+        self.memos_message_queue: Queue[ScheduleMessageItem] = Queue(
+            maxsize=self.max_internal_messae_queue_size
+        )
+        self._web_log_message_queue: Queue[ScheduleLogForWebItem] = Queue(
+            maxsize=self.max_internal_messae_queue_size
+        )
         self._consumer_thread = None  # Reference to our consumer thread
         self._running = False
         self._consume_interval = self.config.get(
             "consume_interval_seconds", DEFAULT_CONSUME_INTERVAL_SECONDS
         )
 
-        # others
+        # other attributes
+        self._context_lock = threading.Lock()
         self._current_user_id: str | None = None
+        self.auth_config_path: str | Path | None = self.config.get("auth_config_path", None)
+        self.auth_config = None
+        self.rabbitmq_config = None
+
+    def initialize_modules(self, chat_llm: BaseLLM, process_llm: BaseLLM | None = None):
+        if process_llm is None:
+            process_llm = chat_llm
+
+        # initialize submodules
+        self.chat_llm = chat_llm
+        self.process_llm = process_llm
+        self.monitor = SchedulerMonitor(process_llm=self.process_llm, config=self.config)
+        self.retriever = SchedulerRetriever(process_llm=self.process_llm, config=self.config)
+        self.retriever.log_working_memory_replacement = self.log_working_memory_replacement
+
+        # initialize with auth_cofig
+        if self.auth_config_path is not None and Path(self.auth_config_path).exists():
+            self.auth_config = AuthConfig.from_local_yaml(config_path=self.auth_config_path)
+        elif AuthConfig.default_config_exists():
+            self.auth_config = AuthConfig.from_local_yaml()
+        else:
+            self.auth_config = None
+
+        if self.auth_config is not None:
+            self.rabbitmq_config = self.auth_config.rabbitmq
+            self.initialize_rabbitmq(config=self.rabbitmq_config)
 
-    @abstractmethod
-    def initialize_modules(self, chat_llm: BaseLLM) -> None:
-        """Initialize all necessary modules for the scheduler
+        logger.debug("GeneralScheduler has been initialized")
+
+    @property
+    def mem_cube(self) -> GeneralMemCube:
+        """The memory cube associated with this MemChat."""
+        return self._current_mem_cube
+
+    @mem_cube.setter
+    def mem_cube(self, value: GeneralMemCube) -> None:
+        """The memory cube associated with this MemChat."""
+        self._current_mem_cube = value
+        self.retriever.mem_cube = value
+
+    def _set_current_context_from_message(self, msg: ScheduleMessageItem) -> None:
+        """Update current user/cube context from the incoming message (thread-safe)."""
+        with self._context_lock:
+            self._current_user_id = msg.user_id
+            self._current_mem_cube_id = msg.mem_cube_id
+            self._current_mem_cube = msg.mem_cube
+
+    def _validate_messages(self, messages: list[ScheduleMessageItem], label: str):
+        """Validate if all messages match the expected label.
+
+        Args:
+            messages: List of message items to validate.
+            label: Expected message label (e.g., QUERY_LABEL/ANSWER_LABEL).
+
+        Returns:
+            bool: True if all messages passed validation, False if any failed.
+        """
+        for message in messages:
+            if not self._validate_message(message, label):
+                return False
+                logger.error("Message batch contains invalid labels, aborting processing")
+        return True
+
+    def _validate_message(self, message: ScheduleMessageItem, label: str):
+        """Validate if the message matches the expected label.
 
         Args:
-            chat_llm: The LLM instance to be used for chat interactions
+            message: Incoming message item to validate.
+            label: Expected message label (e.g., QUERY_LABEL/ANSWER_LABEL).
+
+        Returns:
+            bool: True if validation passed, False otherwise.
+        """
+        if message.label != label:
+            logger.error(f"Handler validation failed: expected={label}, actual={message.label}")
+            return False
+        return True
+
+    def update_activation_memory(
+        self,
+        new_memories: list[str | TextualMemoryItem],
+        label: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ) -> None:
         """
+        Update activation memory by extracting KVCacheItems from new_memory (list of str),
+        add them to a KVCacheMemory instance, and dump to disk.
+        """
+        if len(new_memories) == 0:
+            logger.error("update_activation_memory: new_memory is empty.")
+            return
+        if isinstance(new_memories[0], TextualMemoryItem):
+            new_text_memories = [mem.memory for mem in new_memories]
+        elif isinstance(new_memories[0], str):
+            new_text_memories = new_memories
+        else:
+            logger.error("Not Implemented.")
+
+        try:
+            if isinstance(mem_cube.act_mem, VLLMKVCacheMemory):
+                act_mem: VLLMKVCacheMemory = mem_cube.act_mem
+            elif isinstance(mem_cube.act_mem, KVCacheMemory):
+                act_mem: KVCacheMemory = mem_cube.act_mem
+            else:
+                logger.error("Not Implemented.")
+                return
+
+            text_memory = MEMORY_ASSEMBLY_TEMPLATE.format(
+                memory_text="".join(
+                    [
+                        f"{i + 1}. {sentence.strip()}\n"
+                        for i, sentence in enumerate(new_text_memories)
+                        if sentence.strip()  # Skip empty strings
+                    ]
+                )
+            )
+
+            # huggingface or vllm kv cache
+            original_cache_items: list[VLLMKVCacheItem] = act_mem.get_all()
+            original_text_memories = []
+            if len(original_cache_items) > 0:
+                pre_cache_item: VLLMKVCacheItem = original_cache_items[-1]
+                original_text_memories = pre_cache_item.records.text_memories
+                act_mem.delete_all()
+
+            cache_item = act_mem.extract(text_memory)
+            cache_item.records.text_memories = new_text_memories
+
+            act_mem.add([cache_item])
+            act_mem.dump(self.act_mem_dump_path)
+
+            self.log_activation_memory_update(
+                original_text_memories=original_text_memories,
+                new_text_memories=new_text_memories,
+                label=label,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+
+        except Exception as e:
+            logger.warning(f"MOS-based activation memory update failed: {e}", exc_info=True)
+
+    def update_activation_memory_periodically(
+        self,
+        interval_seconds: int,
+        label: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ):
+        new_activation_memories = []
+
+        if self.monitor.timed_trigger(
+            last_time=self.monitor._last_activation_mem_update_time,
+            interval_seconds=interval_seconds,
+        ):
+            logger.info(f"Updating activation memory for user {user_id} and mem_cube {mem_cube_id}")
+
+            self.monitor.update_memory_monitors(
+                user_id=user_id, mem_cube_id=mem_cube_id, mem_cube=mem_cube
+            )
+
+            new_activation_memories = [
+                m.memory_text
+                for m in self.monitor.activation_memory_monitors[user_id][mem_cube_id].memories
+            ]
+
+            logger.info(
+                f"Collected {len(new_activation_memories)} new memory entries for processing"
+            )
+
+            self.update_activation_memory(
+                new_memories=new_activation_memories,
+                label=label,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+
+            self.monitor._last_activation_mem_update_time = datetime.now()
+
+            logger.debug(
+                f"Activation memory update completed at {self.monitor._last_activation_mem_update_time}"
+            )
+        else:
+            logger.info(
+                f"Skipping update - {interval_seconds} second interval not yet reached. "
+                f"Last update time is {self.monitor._last_activation_mem_update_time} and now is"
+                f"{datetime.now()}"
+            )
 
     def submit_messages(self, messages: ScheduleMessageItem | list[ScheduleMessageItem]):
         """Submit multiple messages to the message queue."""
@@ -68,15 +290,185 @@ class BaseScheduler(RedisSchedulerModule):
             logger.info(f"Submitted message: {message.label} - {message.content}")
 
     def _submit_web_logs(self, messages: ScheduleLogForWebItem | list[ScheduleLogForWebItem]):
+        """Submit log messages to the web log queue and optionally to RabbitMQ.
+
+        Args:
+            messages: Single log message or list of log messages
+        """
         if isinstance(messages, ScheduleLogForWebItem):
             messages = [messages]  # transform single message to list
 
         for message in messages:
             self._web_log_message_queue.put(message)
+            logger.info(f"Submitted Scheduling log for web: {message.log_content}")
+
+            if self.is_rabbitmq_connected():
+                logger.info("Submitted Scheduling log to rabbitmq")
+                self.rabbitmq_publish_message(message=message.to_dict())
+        logger.debug(f"{len(messages)} submitted. {self._web_log_message_queue.qsize()} in queue.")
+
+    def log_activation_memory_update(
+        self,
+        original_text_memories: list[str],
+        new_text_memories: list[str],
+        label: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ):
+        """Log changes when activation memory is updated.
+
+        Args:
+            original_text_memories: List of original memory texts
+            new_text_memories: List of new memory texts
+        """
+        original_set = set(original_text_memories)
+        new_set = set(new_text_memories)
+
+        # Identify changes
+        added_memories = list(new_set - original_set)  # Present in new but not original
+
+        # recording messages
+        for mem in added_memories:
+            log_message_a = self.create_autofilled_log_item(
+                log_content=mem,
+                label=label,
+                from_memory_type=TEXT_MEMORY_TYPE,
+                to_memory_type=ACTIVATION_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            log_message_b = self.create_autofilled_log_item(
+                log_content=mem,
+                label=label,
+                from_memory_type=ACTIVATION_MEMORY_TYPE,
+                to_memory_type=PARAMETER_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            self._submit_web_logs(messages=[log_message_a, log_message_b])
             logger.info(
-                f"Submitted Scheduling log for web: {message.log_title} - {message.log_content}"
+                f"{len(added_memories)} {LONG_TERM_MEMORY_TYPE} memorie(s) "
+                f"transformed to {WORKING_MEMORY_TYPE} memories."
             )
-        logger.debug(f"{len(messages)} submitted. {self._web_log_message_queue.qsize()} in queue.")
+
+    def log_working_memory_replacement(
+        self,
+        original_memory: list[TextualMemoryItem],
+        new_memory: list[TextualMemoryItem],
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ):
+        """Log changes when working memory is replaced."""
+        memory_type_map = {
+            transform_name_to_key(name=m.memory): m.metadata.memory_type
+            for m in original_memory + new_memory
+        }
+
+        original_text_memories = [m.memory for m in original_memory]
+        new_text_memories = [m.memory for m in new_memory]
+
+        # Convert to sets for efficient difference operations
+        original_set = set(original_text_memories)
+        new_set = set(new_text_memories)
+
+        # Identify changes
+        added_memories = list(new_set - original_set)  # Present in new but not original
+
+        # recording messages
+        for mem in added_memories:
+            normalized_mem = transform_name_to_key(name=mem)
+            if normalized_mem not in memory_type_map:
+                logger.error(f"Memory text not found in type mapping: {mem[:50]}...")
+            # Get the memory type from the map, default to LONG_TERM_MEMORY_TYPE if not found
+            mem_type = memory_type_map.get(normalized_mem, LONG_TERM_MEMORY_TYPE)
+
+            if mem_type == WORKING_MEMORY_TYPE:
+                logger.warning(f"Memory already in working memory: {mem[:50]}...")
+                continue
+
+            log_message = self.create_autofilled_log_item(
+                log_content=mem,
+                label=QUERY_LABEL,
+                from_memory_type=mem_type,
+                to_memory_type=WORKING_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            self._submit_web_logs(messages=log_message)
+            logger.info(
+                f"{len(added_memories)} {LONG_TERM_MEMORY_TYPE} memorie(s) "
+                f"transformed to {WORKING_MEMORY_TYPE} memories."
+            )
+
+    def log_adding_user_inputs(
+        self,
+        user_inputs: list[str],
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ):
+        """Log changes when working memory is replaced."""
+
+        # recording messages
+        for input_str in user_inputs:
+            log_message = self.create_autofilled_log_item(
+                log_content=input_str,
+                label=ADD_LABEL,
+                from_memory_type=USER_INPUT_TYPE,
+                to_memory_type=TEXT_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            self._submit_web_logs(messages=log_message)
+            logger.info(
+                f"{len(user_inputs)} {USER_INPUT_TYPE} memorie(s) "
+                f"transformed to {TEXT_MEMORY_TYPE} memories."
+            )
+
+    def create_autofilled_log_item(
+        self,
+        log_content: str,
+        label: str,
+        from_memory_type: str,
+        to_memory_type: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ) -> ScheduleLogForWebItem:
+        text_mem_base: TreeTextMemory = mem_cube.text_mem
+        current_memory_sizes = text_mem_base.get_current_memory_size()
+        current_memory_sizes = {
+            "long_term_memory_size": current_memory_sizes["LongTermMemory"],
+            "user_memory_size": current_memory_sizes["UserMemory"],
+            "working_memory_size": current_memory_sizes["WorkingMemory"],
+            "transformed_act_memory_size": NOT_INITIALIZED,
+            "parameter_memory_size": NOT_INITIALIZED,
+        }
+        memory_capacities = {
+            "long_term_memory_capacity": text_mem_base.memory_manager.memory_size["LongTermMemory"],
+            "user_memory_capacity": text_mem_base.memory_manager.memory_size["UserMemory"],
+            "working_memory_capacity": text_mem_base.memory_manager.memory_size["WorkingMemory"],
+            "transformed_act_memory_capacity": NOT_INITIALIZED,
+            "parameter_memory_capacity": NOT_INITIALIZED,
+        }
+
+        log_message = ScheduleLogForWebItem(
+            user_id=user_id,
+            mem_cube_id=mem_cube_id,
+            label=label,
+            from_memory_type=from_memory_type,
+            to_memory_type=to_memory_type,
+            log_content=log_content,
+            current_memory_sizes=current_memory_sizes,
+            memory_capacities=memory_capacities,
+        )
+        return log_message
 
     def get_web_log_messages(self) -> list[dict]:
         """
@@ -87,13 +479,12 @@ class BaseScheduler(RedisSchedulerModule):
                        ready for JSON serialization. The list is ordered from oldest to newest.
         """
         messages = []
-
-        # Process all items in the queue
-        while not self._web_log_message_queue.empty():
-            item = self._web_log_message_queue.get()
-            # Convert the ScheduleLogForWebItem to a dictionary and ensure datetime is serialized
-            item_dict = item.to_dict()
-            messages.append(item_dict)
+        while True:
+            try:
+                item = self._web_log_message_queue.get_nowait()  # 线程安全的 get
+                messages.append(item.to_dict())
+            except queue.Empty:
+                break
         return messages
 
     def _message_consumer(self) -> None:
@@ -133,32 +524,72 @@ class BaseScheduler(RedisSchedulerModule):
 
     def start(self) -> None:
         """
-        Start the message consumer thread.
+        Start the message consumer thread and initialize dispatcher resources.
 
-        Initializes and starts a daemon thread that will periodically
-        check for and process messages from the queue.
+        Initializes and starts:
+        1. Message consumer thread
+        2. Dispatcher thread pool (if parallel dispatch enabled)
         """
-        if self._consumer_thread is not None and self._consumer_thread.is_alive():
-            logger.warning("Consumer thread is already running")
+        if self._running:
+            logger.warning("Memory Scheduler is already running")
             return
 
+        # Initialize dispatcher resources
+        if self.enable_parallel_dispatch:
+            logger.info(f"Initializing dispatcher thread pool with {self.max_workers} workers")
+
+        # Start consumer thread
         self._running = True
         self._consumer_thread = threading.Thread(
             target=self._message_consumer,
-            daemon=True,  # Allows program to exit even if thread is running
+            daemon=True,
             name="MessageConsumerThread",
         )
         self._consumer_thread.start()
         logger.info("Message consumer thread started")
 
     def stop(self) -> None:
-        """Stop the consumer thread and clean up resources."""
-        if self._consumer_thread is None or not self._running:
-            logger.warning("Consumer thread is not running")
+        """Stop all scheduler components gracefully.
+
+        1. Stops message consumer thread
+        2. Shuts down dispatcher thread pool
+        3. Cleans up resources
+        """
+        if not self._running:
+            logger.warning("Memory Scheduler is not running")
             return
+
+        # Signal consumer thread to stop
         self._running = False
-        if self._consumer_thread.is_alive():
-            self._consumer_thread.join(timeout=5.0)  # Wait up to 5 seconds
+
+        # Wait for consumer thread
+        if self._consumer_thread and self._consumer_thread.is_alive():
+            self._consumer_thread.join(timeout=5.0)
             if self._consumer_thread.is_alive():
                 logger.warning("Consumer thread did not stop gracefully")
-        logger.info("Message consumer thread stopped")
+            else:
+                logger.info("Consumer thread stopped")
+
+        # Shutdown dispatcher
+        if hasattr(self, "dispatcher") and self.dispatcher:
+            logger.info("Shutting down dispatcher...")
+            self.dispatcher.shutdown()
+
+        # Clean up queues
+        self._cleanup_queues()
+        logger.info("Memory Scheduler stopped completely")
+
+    def _cleanup_queues(self) -> None:
+        """Ensure all queues are emptied and marked as closed."""
+        try:
+            while not self.memos_message_queue.empty():
+                self.memos_message_queue.get_nowait()
+                self.memos_message_queue.task_done()
+        except queue.Empty:
+            pass
+
+        try:
+            while not self._web_log_message_queue.empty():
+                self._web_log_message_queue.get_nowait()
+        except queue.Empty:
+            pass