From 5cb88dad1b5efd0ecd14d39a20e3a2f985a35737 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Thu, 14 Sep 2023 11:45:47 +0200
Subject: [PATCH 01/12] chat: implemented special version of 'latest_message()'
 for the ChatDB class

---
 chatmastermind/chat.py | 44 ++++++++++++++++++++++++++++++++++++------
 tests/test_chat.py     | 27 ++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 6 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index dd18293..f3637de 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -6,7 +6,7 @@ from pathlib import Path
 from pprint import PrettyPrinter
 from pydoc import pager
 from dataclasses import dataclass
-from typing import TypeVar, Type, Optional, ClassVar, Any, Callable
+from typing import TypeVar, Type, Optional, ClassVar, Any, Callable, Literal
 from .message import Message, MessageFilter, MessageError, message_in
 from .tags import Tag
 
@@ -142,15 +142,18 @@ class Chat:
         self.messages += messages
         self.sort()
 
-    def latest_message(self) -> Optional[Message]:
+    def latest_message(self, mfilter: Optional[MessageFilter] = None) -> Optional[Message]:
         """
-        Returns the last added message (according to the file ID).
+        Return the last added message (according to the file ID) that matches the given filter.
+        When containing messages without a valid file_path, it returns the latest message in
+        the internal list.
         """
         if len(self.messages) > 0:
             self.sort()
-            return self.messages[-1]
-        else:
-            return None
+            for m in reversed(self.messages):
+                if mfilter is None or m.match(mfilter):
+                    return m
+        return None
 
     def find_messages(self, msg_names: list[str]) -> list[Message]:
         """
@@ -404,3 +407,32 @@ class ChatDB(Chat):
         # write the UPDATED messages if requested
         if write:
             self.write_messages(messages)
+
+    def latest_message(self,
+                       mfilter: Optional[MessageFilter] = None,
+                       source: Literal['mem', 'disk', 'cache', 'db', 'all'] = 'mem') -> Optional[Message]:
+        """
+        Return the last added message (according to the file ID) that matches the given filter.
+        Only consider messages with a valid file_path (except if source is 'mem').
+        Searches one of the following sources:
+        * 'mem'  : only search messages currently in memory
+        * 'disk' : search messages on disk (cache + DB directory), but not in memory
+        * 'cache': only search messages in the cache directory
+        * 'db'   : only search messages in the DB directory
+        * 'all'  : search all messages ('mem' + 'disk')
+        """
+        source_messages: list[Message] = []
+        if source == 'mem':
+            return super().latest_message(mfilter)
+        if source in ['cache', 'disk', 'all']:
+            source_messages += read_dir(self.cache_path, mfilter=mfilter)
+        if source in ['db', 'disk', 'all']:
+            source_messages += read_dir(self.db_path, mfilter=mfilter)
+        if source in ['all']:
+            # only consider messages with a valid file_path so they can be sorted
+            source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
+        source_messages.sort(key=lambda m: m.msg_id(), reverse=True)
+        for m in source_messages:
+            if mfilter is None or m.match(mfilter):
+                return m
+        return None
diff --git a/tests/test_chat.py b/tests/test_chat.py
index f34cb24..ca74725 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -84,6 +84,13 @@ class TestChat(unittest.TestCase):
         self.chat.remove_messages(['0003.txt'])
         self.assertListEqual(self.chat.messages, [self.message1, self.message2])
 
+    def test_latest_message(self) -> None:
+        self.assertIsNone(self.chat.latest_message())
+        self.chat.add_messages([self.message1])
+        self.assertEqual(self.chat.latest_message(), self.message1)
+        self.chat.add_messages([self.message2])
+        self.assertEqual(self.chat.latest_message(), self.message2)
+
     @patch('sys.stdout', new_callable=StringIO)
     def test_print(self, mock_stdout: StringIO) -> None:
         self.chat.add_messages([self.message1, self.message2])
@@ -474,3 +481,23 @@ class TestChatDB(unittest.TestCase):
                            answer=Answer("Answer 1"))
         with self.assertRaises(ChatError):
             chat_db.update_messages([message1])
+
+    def test_chat_db_latest_message(self) -> None:
+        chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
+                                  pathlib.Path(self.db_path.name))
+        self.assertEqual(chat_db.latest_message(source='mem'), self.message4)
+        self.assertEqual(chat_db.latest_message(source='db'), self.message4)
+        self.assertEqual(chat_db.latest_message(source='disk'), self.message4)
+        self.assertEqual(chat_db.latest_message(source='all'), self.message4)
+        # the cache is currently empty:
+        self.assertIsNone(chat_db.latest_message(source='cache'))
+        # add new messages to the cache dir
+        new_message = Message(question=Question("New Question"),
+                              answer=Answer("New Answer"))
+        chat_db.add_to_cache([new_message])
+        self.assertEqual(chat_db.latest_message(source='cache'), new_message)
+        self.assertEqual(chat_db.latest_message(source='mem'), new_message)
+        self.assertEqual(chat_db.latest_message(source='disk'), new_message)
+        self.assertEqual(chat_db.latest_message(source='all'), new_message)
+        # the DB does not contain the new message
+        self.assertEqual(chat_db.latest_message(source='db'), self.message4)
-- 
2.36.6


From 071871f929cbbc5bcccbbeca050924a702a2cf65 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Thu, 14 Sep 2023 12:45:11 +0200
Subject: [PATCH 02/12] chat et al: '.next' and '.config.yaml' are now ignored
 by ChatDB

---
 chatmastermind/chat.py          | 14 ++++++++++----
 chatmastermind/configuration.py |  2 +-
 chatmastermind/main.py          |  4 ++--
 tests/test_chat.py              |  2 +-
 4 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index f3637de..8d64f86 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -7,12 +7,16 @@ from pprint import PrettyPrinter
 from pydoc import pager
 from dataclasses import dataclass
 from typing import TypeVar, Type, Optional, ClassVar, Any, Callable, Literal
+from .configuration import default_config_file
 from .message import Message, MessageFilter, MessageError, message_in
 from .tags import Tag
 
 ChatInst = TypeVar('ChatInst', bound='Chat')
 ChatDBInst = TypeVar('ChatDBInst', bound='ChatDB')
 
+db_next_file = '.next'
+ignored_files = [db_next_file, default_config_file]
+
 
 class ChatError(Exception):
     pass
@@ -45,7 +49,9 @@ def read_dir(dir_path: Path,
     messages: list[Message] = []
     file_iter = dir_path.glob(glob) if glob else dir_path.iterdir()
     for file_path in sorted(file_iter):
-        if file_path.is_file() and file_path.suffix in Message.file_suffixes:
+        if (file_path.is_file()
+           and file_path.name not in ignored_files  # noqa: W503
+           and file_path.suffix in Message.file_suffixes):  # noqa: W503
             try:
                 message = Message.from_file(file_path, mfilter)
                 if message:
@@ -235,7 +241,7 @@ class ChatDB(Chat):
 
     def __post_init__(self) -> None:
         # contains the latest message ID
-        self.next_fname = self.db_path / '.next'
+        self.next_path = self.db_path / db_next_file
         # make all paths absolute
         self.cache_path = self.cache_path.absolute()
         self.db_path = self.db_path.absolute()
@@ -274,7 +280,7 @@ class ChatDB(Chat):
 
     def get_next_fid(self) -> int:
         try:
-            with open(self.next_fname, 'r') as f:
+            with open(self.next_path, 'r') as f:
                 next_fid = int(f.read()) + 1
             self.set_next_fid(next_fid)
             return next_fid
@@ -283,7 +289,7 @@ class ChatDB(Chat):
             return 1
 
     def set_next_fid(self, fid: int) -> None:
-        with open(self.next_fname, 'w') as f:
+        with open(self.next_path, 'w') as f:
             f.write(f'{fid}')
 
     def read_db(self) -> None:
diff --git a/chatmastermind/configuration.py b/chatmastermind/configuration.py
index 1415eb2..d1f9601 100644
--- a/chatmastermind/configuration.py
+++ b/chatmastermind/configuration.py
@@ -9,7 +9,7 @@ OpenAIConfigInst = TypeVar('OpenAIConfigInst', bound='OpenAIConfig')
 
 
 supported_ais: list[str] = ['openai']
-default_config_path = '.config.yaml'
+default_config_file = '.config.yaml'
 
 
 class ConfigError(Exception):
diff --git a/chatmastermind/main.py b/chatmastermind/main.py
index 7e18185..fcd1b2f 100755
--- a/chatmastermind/main.py
+++ b/chatmastermind/main.py
@@ -7,7 +7,7 @@ import argcomplete
 import argparse
 from pathlib import Path
 from typing import Any
-from .configuration import Config, default_config_path
+from .configuration import Config, default_config_file
 from .message import Message
 from .commands.question import question_cmd
 from .commands.tags import tags_cmd
@@ -24,7 +24,7 @@ def tags_completer(prefix: str, parsed_args: Any, **kwargs: Any) -> list[str]:
 def create_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         description="ChatMastermind is a Python application that automates conversation with AI")
-    parser.add_argument('-C', '--config', help='Config file name.', default=default_config_path)
+    parser.add_argument('-C', '--config', help='Config file name.', default=default_config_file)
 
     # subcommand-parser
     cmdparser = parser.add_subparsers(dest='command',
diff --git a/tests/test_chat.py b/tests/test_chat.py
index ca74725..ff44cda 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -241,7 +241,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.get_next_fid(), 5)
         self.assertEqual(chat_db.get_next_fid(), 6)
         self.assertEqual(chat_db.get_next_fid(), 7)
-        with open(chat_db.next_fname, 'r') as f:
+        with open(chat_db.next_path, 'r') as f:
             self.assertEqual(f.read(), '7')
 
     def test_chat_db_write(self) -> None:
-- 
2.36.6


From f6109949c816d350244d396a3d13ea302f8c38b8 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Thu, 14 Sep 2023 16:05:18 +0200
Subject: [PATCH 03/12] chat: ChatDB now correctly ignores files that contain
 no valid messages

---
 chatmastermind/chat.py    |  2 +-
 chatmastermind/message.py | 11 +++++++----
 tests/test_chat.py        | 14 +++++++++++++-
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index 8d64f86..c1464c3 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -57,7 +57,7 @@ def read_dir(dir_path: Path,
                 if message:
                     messages.append(message)
             except MessageError as e:
-                print(f"Error processing message in '{file_path}': {str(e)}")
+                print(f"WARNING: Skipping message in '{file_path}': {str(e)}")
     return messages
 
 
diff --git a/chatmastermind/message.py b/chatmastermind/message.py
index 64929a3..402a6d1 100644
--- a/chatmastermind/message.py
+++ b/chatmastermind/message.py
@@ -370,7 +370,7 @@ class Message():
             try:
                 question_idx = text.index(Question.txt_header) + 1
             except ValueError:
-                raise MessageError(f"Question header '{Question.txt_header}' not found in '{file_path}'")
+                raise MessageError(f"'{file_path}' does not contain a valid message")
             try:
                 answer_idx = text.index(Answer.txt_header)
                 question = Question.from_list(text[question_idx:answer_idx])
@@ -390,9 +390,12 @@ class Message():
             * Message.model_yaml_key: str [Optional]
         """
         with open(file_path, "r") as fd:
-            data = yaml.load(fd, Loader=yaml.FullLoader)
-            data[cls.file_yaml_key] = file_path
-            return cls.from_dict(data)
+            try:
+                data = yaml.load(fd, Loader=yaml.FullLoader)
+                data[cls.file_yaml_key] = file_path
+                return cls.from_dict(data)
+            except Exception:
+                raise MessageError(f"'{file_path}' does not contain a valid message")
 
     def to_str(self, with_tags: bool = False, with_file: bool = False, source_code_only: bool = False) -> str:
         """
diff --git a/tests/test_chat.py b/tests/test_chat.py
index ff44cda..bca3a9f 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -2,6 +2,7 @@ import unittest
 import pathlib
 import tempfile
 import time
+import yaml
 from io import StringIO
 from unittest.mock import patch
 from chatmastermind.tags import TagLine
@@ -156,13 +157,24 @@ class TestChatDB(unittest.TestCase):
         next_fname = pathlib.Path(self.db_path.name) / '.next'
         with open(next_fname, 'w') as f:
             f.write('4')
+        # add some "trash" in order to test if it's correctly handled / ignored
+        self.trash_files = ['.config.yaml', 'foo.yaml', 'bla.txt']
+        for file in self.trash_files:
+            with open(pathlib.Path(self.db_path.name) / file, 'w') as f:
+                f.write('test trash')
+        # also create a file with actual yaml content
+        with open(pathlib.Path(self.db_path.name) / 'content.yaml', 'w') as f:
+            yaml.dump({'key': 'value'}, f)
+        self.trash_files.append('content.yaml')
+
+        self.maxDiff = None
 
     def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[pathlib.Path]:
         """
         List all Message files in the given TemporaryDirectory.
         """
         # exclude '.next'
-        return list(pathlib.Path(tmp_dir.name).glob('*.[ty]*'))
+        return [f for f in pathlib.Path(tmp_dir.name).glob('*.[ty]*') if f.name not in self.trash_files]
 
     def tearDown(self) -> None:
         self.db_path.cleanup()
-- 
2.36.6


From 98777295d62a40b8af547da005f810f58849c8cf Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 08:41:32 +0200
Subject: [PATCH 04/12] refactor: renamed (almost) all Chat/ChatDB functions

---
 chatmastermind/chat.py              | 239 ++++++++++++++--------------
 chatmastermind/commands/question.py |  11 +-
 chatmastermind/commands/tags.py     |   2 +-
 tests/test_chat.py                  | 118 +++++++-------
 tests/test_question_cmd.py          |   2 +-
 5 files changed, 186 insertions(+), 186 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index c1464c3..8823da4 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -118,14 +118,14 @@ class Chat:
 
     messages: list[Message]
 
-    def filter(self, mfilter: MessageFilter) -> None:
+    def msg_filter(self, mfilter: MessageFilter) -> None:
         """
         Use 'Message.match(mfilter) to remove all messages that
         don't fulfill the filter requirements.
         """
         self.messages = [m for m in self.messages if m.match(mfilter)]
 
-    def sort(self, reverse: bool = False) -> None:
+    def msg_sort(self, reverse: bool = False) -> None:
         """
         Sort the messages according to 'Message.msg_id()'.
         """
@@ -135,33 +135,33 @@ class Chat:
         except MessageError:
             pass
 
-    def clear(self) -> None:
+    def msg_clear(self) -> None:
         """
         Delete all messages.
         """
         self.messages = []
 
-    def add_messages(self, messages: list[Message]) -> None:
+    def msg_add(self, messages: list[Message]) -> None:
         """
         Add new messages and sort them if possible.
         """
         self.messages += messages
-        self.sort()
+        self.msg_sort()
 
-    def latest_message(self, mfilter: Optional[MessageFilter] = None) -> Optional[Message]:
+    def msg_latest(self, mfilter: Optional[MessageFilter] = None) -> Optional[Message]:
         """
         Return the last added message (according to the file ID) that matches the given filter.
         When containing messages without a valid file_path, it returns the latest message in
         the internal list.
         """
         if len(self.messages) > 0:
-            self.sort()
+            self.msg_sort()
             for m in reversed(self.messages):
                 if mfilter is None or m.match(mfilter):
                     return m
         return None
 
-    def find_messages(self, msg_names: list[str]) -> list[Message]:
+    def msg_find(self, msg_names: list[str]) -> list[Message]:
         """
         Search and return the messages with the given names. Names can either be filenames
         (incl. suffixes) or full paths. Messages that can't be found are ignored (i. e. the
@@ -170,16 +170,16 @@ class Chat:
         return [m for m in self.messages
                 if any((m.file_path and (m.file_path == Path(mn) or m.file_path.name == mn)) for mn in msg_names)]
 
-    def remove_messages(self, msg_names: list[str]) -> None:
+    def msg_remove(self, msg_names: list[str]) -> None:
         """
         Remove the messages with the given names. Names can either be filenames
         (incl. the suffix) or full paths.
         """
         self.messages = [m for m in self.messages
                          if not any((m.file_path and (m.file_path == Path(mn) or m.file_path.name == mn)) for mn in msg_names)]
-        self.sort()
+        self.msg_sort()
 
-    def tags(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> set[Tag]:
+    def msg_tags(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> set[Tag]:
         """
         Get the tags of all messages, optionally filtered by prefix or substring.
         """
@@ -188,7 +188,7 @@ class Chat:
             tags |= m.filter_tags(prefix, contain)
         return set(sorted(tags))
 
-    def tags_frequency(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> dict[Tag, int]:
+    def msg_tags_frequency(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> dict[Tag, int]:
         """
         Get the frequency of all tags of all messages, optionally filtered by prefix or substring.
         """
@@ -292,44 +292,78 @@ class ChatDB(Chat):
         with open(self.next_path, 'w') as f:
             f.write(f'{fid}')
 
-    def read_db(self) -> None:
+    def msg_write(self, messages: Optional[list[Message]] = None) -> None:
         """
-        Reads new messages from the DB directory. New ones are added to the internal list,
-        existing ones are replaced. A message is determined as 'existing' if a message with
-        the same base filename (i. e. 'file_path.name') is already in the list.
+        Write either the given messages or the internal ones to their CURRENT file_path.
+        If messages are given, they all must have a valid file_path. When writing the
+        internal messages, the ones with a valid file_path are written, the others
+        are ignored.
         """
-        new_messages = read_dir(self.db_path, self.glob, self.mfilter)
-        # remove all messages from self.messages that are in the new list
-        self.messages = [m for m in self.messages if not message_in(m, new_messages)]
-        # copy the messages from the temporary list to self.messages and sort them
-        self.messages += new_messages
-        self.sort()
+        if messages and any(m.file_path is None for m in messages):
+            raise ChatError("Can't write files without a valid file_path")
+        msgs = iter(messages if messages else self.messages)
+        while (m := next(msgs, None)):
+            m.to_file()
 
-    def read_cache(self) -> None:
+    def msg_update(self, messages: list[Message], write: bool = True) -> None:
         """
-        Reads new messages from the cache directory. New ones are added to the internal list,
-        existing ones are replaced. A message is determined as 'existing' if a message with
-        the same base filename (i. e. 'file_path.name') is already in the list.
+        Update EXISTING messages. A message is determined as 'existing' if a message with
+        the same base filename (i. e. 'file_path.name') is already in the list. Only accepts
+        existing messages.
+        """
+        if any(not message_in(m, self.messages) for m in messages):
+            raise ChatError("Can't update messages that are not in the internal list")
+        # remove old versions and add new ones
+        self.messages = [m for m in self.messages if not message_in(m, messages)]
+        self.messages += messages
+        self.msg_sort()
+        # write the UPDATED messages if requested
+        if write:
+            self.msg_write(messages)
+
+    def msg_latest(self,
+                   mfilter: Optional[MessageFilter] = None,
+                   source: Literal['mem', 'disk', 'cache', 'db', 'all'] = 'mem') -> Optional[Message]:
+        """
+        Return the last added message (according to the file ID) that matches the given filter.
+        Only consider messages with a valid file_path (except if source is 'mem').
+        Searches one of the following sources:
+        * 'mem'  : only search messages currently in memory
+        * 'disk' : search messages on disk (cache + DB directory), but not in memory
+        * 'cache': only search messages in the cache directory
+        * 'db'   : only search messages in the DB directory
+        * 'all'  : search all messages ('mem' + 'disk')
+        """
+        source_messages: list[Message] = []
+        if source == 'mem':
+            return super().msg_latest(mfilter)
+        if source in ['cache', 'disk', 'all']:
+            source_messages += read_dir(self.cache_path, mfilter=mfilter)
+        if source in ['db', 'disk', 'all']:
+            source_messages += read_dir(self.db_path, mfilter=mfilter)
+        if source in ['all']:
+            # only consider messages with a valid file_path so they can be sorted
+            source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
+        source_messages.sort(key=lambda m: m.msg_id(), reverse=True)
+        for m in source_messages:
+            if mfilter is None or m.match(mfilter):
+                return m
+        return None
+
+    def cache_read(self) -> None:
+        """
+        Read messages from the cache directory. New ones are added to the internal list,
+        existing ones are replaced. A message is determined as 'existing' if a message
+        with the same base filename (i. e. 'file_path.name') is already in the list.
         """
         new_messages = read_dir(self.cache_path, self.glob, self.mfilter)
         # remove all messages from self.messages that are in the new list
         self.messages = [m for m in self.messages if not message_in(m, new_messages)]
         # copy the messages from the temporary list to self.messages and sort them
         self.messages += new_messages
-        self.sort()
+        self.msg_sort()
 
-    def write_db(self, messages: Optional[list[Message]] = None) -> None:
-        """
-        Write messages to the DB directory. If a message has no file_path, a new one
-        will be created. If message.file_path exists, it will be modified to point
-        to the DB directory.
-        """
-        write_dir(self.db_path,
-                  messages if messages else self.messages,
-                  self.file_suffix,
-                  self.get_next_fid)
-
-    def write_cache(self, messages: Optional[list[Message]] = None) -> None:
+    def cache_write(self, messages: Optional[list[Message]] = None) -> None:
         """
         Write messages to the cache directory. If a message has no file_path, a new one
         will be created. If message.file_path exists, it will be modified to point to
@@ -340,36 +374,9 @@ class ChatDB(Chat):
                   self.file_suffix,
                   self.get_next_fid)
 
-    def clear_cache(self) -> None:
+    def cache_add(self, messages: list[Message], write: bool = True) -> None:
         """
-        Deletes all Message files from the cache dir and removes those messages from
-        the internal list.
-        """
-        clear_dir(self.cache_path, self.glob)
-        # only keep messages from DB dir (or those that have not yet been written)
-        self.messages = [m for m in self.messages if not m.file_path or m.file_path.parent.samefile(self.db_path)]
-
-    def add_to_db(self, messages: list[Message], write: bool = True) -> None:
-        """
-        Add the given new messages and set the file_path to the DB directory.
-        Only accepts messages without a file_path.
-        """
-        if any(m.file_path is not None for m in messages):
-            raise ChatError("Can't add new messages with existing file_path")
-        if write:
-            write_dir(self.db_path,
-                      messages,
-                      self.file_suffix,
-                      self.get_next_fid)
-        else:
-            for m in messages:
-                m.file_path = make_file_path(self.db_path, self.default_file_suffix, self.get_next_fid)
-        self.messages += messages
-        self.sort()
-
-    def add_to_cache(self, messages: list[Message], write: bool = True) -> None:
-        """
-        Add the given new messages and set the file_path to the cache directory.
+        Add NEW messages and set the file_path to the cache directory.
         Only accepts messages without a file_path.
         """
         if any(m.file_path is not None for m in messages):
@@ -383,62 +390,54 @@ class ChatDB(Chat):
             for m in messages:
                 m.file_path = make_file_path(self.cache_path, self.default_file_suffix, self.get_next_fid)
         self.messages += messages
-        self.sort()
+        self.msg_sort()
 
-    def write_messages(self, messages: Optional[list[Message]] = None) -> None:
+    def cache_clear(self) -> None:
         """
-        Write either the given messages or the internal ones to their current file_path.
-        If messages are given, they all must have a valid file_path. When writing the
-        internal messages, the ones with a valid file_path are written, the others
-        are ignored.
+        Delete all message files from the cache dir and remove them from the internal list.
         """
-        if messages and any(m.file_path is None for m in messages):
-            raise ChatError("Can't write files without a valid file_path")
-        msgs = iter(messages if messages else self.messages)
-        while (m := next(msgs, None)):
-            m.to_file()
+        clear_dir(self.cache_path, self.glob)
+        # only keep messages from DB dir (or those that have not yet been written)
+        self.messages = [m for m in self.messages if not m.file_path or m.file_path.parent.samefile(self.db_path)]
 
-    def update_messages(self, messages: list[Message], write: bool = True) -> None:
+    def db_read(self) -> None:
         """
-        Update existing messages. A message is determined as 'existing' if a message with
-        the same base filename (i. e. 'file_path.name') is already in the list. Only accepts
-        existing messages.
+        Read messages from the DB directory. New ones are added to the internal list,
+        existing ones are replaced. A message is determined as 'existing' if a message
+        with the same base filename (i. e. 'file_path.name') is already in the list.
         """
-        if any(not message_in(m, self.messages) for m in messages):
-            raise ChatError("Can't update messages that are not in the internal list")
-        # remove old versions and add new ones
-        self.messages = [m for m in self.messages if not message_in(m, messages)]
-        self.messages += messages
-        self.sort()
-        # write the UPDATED messages if requested
+        new_messages = read_dir(self.db_path, self.glob, self.mfilter)
+        # remove all messages from self.messages that are in the new list
+        self.messages = [m for m in self.messages if not message_in(m, new_messages)]
+        # copy the messages from the temporary list to self.messages and sort them
+        self.messages += new_messages
+        self.msg_sort()
+
+    def db_write(self, messages: Optional[list[Message]] = None) -> None:
+        """
+        Write messages to the DB directory. If a message has no file_path, a new one
+        will be created. If message.file_path exists, it will be modified to point
+        to the DB directory.
+        """
+        write_dir(self.db_path,
+                  messages if messages else self.messages,
+                  self.file_suffix,
+                  self.get_next_fid)
+
+    def db_add(self, messages: list[Message], write: bool = True) -> None:
+        """
+        Add NEW messages and set the file_path to the DB directory.
+        Only accepts messages without a file_path.
+        """
+        if any(m.file_path is not None for m in messages):
+            raise ChatError("Can't add new messages with existing file_path")
         if write:
-            self.write_messages(messages)
-
-    def latest_message(self,
-                       mfilter: Optional[MessageFilter] = None,
-                       source: Literal['mem', 'disk', 'cache', 'db', 'all'] = 'mem') -> Optional[Message]:
-        """
-        Return the last added message (according to the file ID) that matches the given filter.
-        Only consider messages with a valid file_path (except if source is 'mem').
-        Searches one of the following sources:
-        * 'mem'  : only search messages currently in memory
-        * 'disk' : search messages on disk (cache + DB directory), but not in memory
-        * 'cache': only search messages in the cache directory
-        * 'db'   : only search messages in the DB directory
-        * 'all'  : search all messages ('mem' + 'disk')
-        """
-        source_messages: list[Message] = []
-        if source == 'mem':
-            return super().latest_message(mfilter)
-        if source in ['cache', 'disk', 'all']:
-            source_messages += read_dir(self.cache_path, mfilter=mfilter)
-        if source in ['db', 'disk', 'all']:
-            source_messages += read_dir(self.db_path, mfilter=mfilter)
-        if source in ['all']:
-            # only consider messages with a valid file_path so they can be sorted
-            source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
-        source_messages.sort(key=lambda m: m.msg_id(), reverse=True)
-        for m in source_messages:
-            if mfilter is None or m.match(mfilter):
-                return m
-        return None
+            write_dir(self.db_path,
+                      messages,
+                      self.file_suffix,
+                      self.get_next_fid)
+        else:
+            for m in messages:
+                m.file_path = make_file_path(self.db_path, self.default_file_suffix, self.get_next_fid)
+        self.messages += messages
+        self.msg_sort()
diff --git a/chatmastermind/commands/question.py b/chatmastermind/commands/question.py
index d143792..78a6c4e 100644
--- a/chatmastermind/commands/question.py
+++ b/chatmastermind/commands/question.py
@@ -51,7 +51,8 @@ def add_file_as_code(question_parts: list[str], file: str) -> None:
 
 def create_message(chat: ChatDB, args: argparse.Namespace) -> Message:
     """
-    Creates (and writes) a new message from the given arguments.
+    Creates a new message from the given arguments and writes it
+    to the cache directory.
     """
     question_parts = []
     question_list = args.ask if args.ask is not None else []
@@ -72,7 +73,7 @@ def create_message(chat: ChatDB, args: argparse.Namespace) -> Message:
                       tags=args.output_tags,  # FIXME
                       ai=args.AI,
                       model=args.model)
-    chat.add_to_cache([message])
+    chat.cache_add([message])
     return message
 
 
@@ -101,8 +102,8 @@ def question_cmd(args: argparse.Namespace, config: Config) -> None:
                                           chat,
                                           args.num_answers,  # FIXME
                                           args.output_tags)  # FIXME
-        chat.update_messages([response.messages[0]])
-        chat.add_to_cache(response.messages[1:])
+        chat.msg_update([response.messages[0]])
+        chat.cache_add(response.messages[1:])
         for idx, msg in enumerate(response.messages):
             print(f"=== ANSWER {idx+1} ===")
             print(msg.answer)
@@ -110,7 +111,7 @@ def question_cmd(args: argparse.Namespace, config: Config) -> None:
             print("===============")
             print(response.tokens)
     elif args.repeat is not None:
-        lmessage = chat.latest_message()
+        lmessage = chat.msg_latest()
         assert lmessage
         # TODO: repeat either the last question or the
         # one(s) given in 'args.repeat' (overwrite
diff --git a/chatmastermind/commands/tags.py b/chatmastermind/commands/tags.py
index 2906a5b..71574ff 100644
--- a/chatmastermind/commands/tags.py
+++ b/chatmastermind/commands/tags.py
@@ -11,7 +11,7 @@ def tags_cmd(args: argparse.Namespace, config: Config) -> None:
     chat = ChatDB.from_dir(cache_path=Path('.'),
                            db_path=Path(config.db))
     if args.list:
-        tags_freq = chat.tags_frequency(args.prefix, args.contain)
+        tags_freq = chat.msg_tags_frequency(args.prefix, args.contain)
         for tag, freq in tags_freq.items():
             print(f"- {tag}: {freq}")
     # TODO: add renaming
diff --git a/tests/test_chat.py b/tests/test_chat.py
index bca3a9f..6aac1b5 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -23,78 +23,78 @@ class TestChat(unittest.TestCase):
                                 file_path=pathlib.Path('0002.txt'))
 
     def test_filter(self) -> None:
-        self.chat.add_messages([self.message1, self.message2])
-        self.chat.filter(MessageFilter(answer_contains='Answer 1'))
+        self.chat.msg_add([self.message1, self.message2])
+        self.chat.msg_filter(MessageFilter(answer_contains='Answer 1'))
 
         self.assertEqual(len(self.chat.messages), 1)
         self.assertEqual(self.chat.messages[0].question, 'Question 1')
 
     def test_sort(self) -> None:
-        self.chat.add_messages([self.message2, self.message1])
-        self.chat.sort()
+        self.chat.msg_add([self.message2, self.message1])
+        self.chat.msg_sort()
         self.assertEqual(self.chat.messages[0].question, 'Question 1')
         self.assertEqual(self.chat.messages[1].question, 'Question 2')
-        self.chat.sort(reverse=True)
+        self.chat.msg_sort(reverse=True)
         self.assertEqual(self.chat.messages[0].question, 'Question 2')
         self.assertEqual(self.chat.messages[1].question, 'Question 1')
 
     def test_clear(self) -> None:
-        self.chat.add_messages([self.message1])
-        self.chat.clear()
+        self.chat.msg_add([self.message1])
+        self.chat.msg_clear()
         self.assertEqual(len(self.chat.messages), 0)
 
     def test_add_messages(self) -> None:
-        self.chat.add_messages([self.message1, self.message2])
+        self.chat.msg_add([self.message1, self.message2])
         self.assertEqual(len(self.chat.messages), 2)
         self.assertEqual(self.chat.messages[0].question, 'Question 1')
         self.assertEqual(self.chat.messages[1].question, 'Question 2')
 
     def test_tags(self) -> None:
-        self.chat.add_messages([self.message1, self.message2])
-        tags_all = self.chat.tags()
+        self.chat.msg_add([self.message1, self.message2])
+        tags_all = self.chat.msg_tags()
         self.assertSetEqual(tags_all, {Tag('atag1'), Tag('btag2')})
-        tags_pref = self.chat.tags(prefix='a')
+        tags_pref = self.chat.msg_tags(prefix='a')
         self.assertSetEqual(tags_pref, {Tag('atag1')})
-        tags_cont = self.chat.tags(contain='2')
+        tags_cont = self.chat.msg_tags(contain='2')
         self.assertSetEqual(tags_cont, {Tag('btag2')})
 
     def test_tags_frequency(self) -> None:
-        self.chat.add_messages([self.message1, self.message2])
-        tags_freq = self.chat.tags_frequency()
+        self.chat.msg_add([self.message1, self.message2])
+        tags_freq = self.chat.msg_tags_frequency()
         self.assertDictEqual(tags_freq, {'atag1': 1, 'btag2': 2})
 
     def test_find_remove_messages(self) -> None:
-        self.chat.add_messages([self.message1, self.message2])
-        msgs = self.chat.find_messages(['0001.txt'])
+        self.chat.msg_add([self.message1, self.message2])
+        msgs = self.chat.msg_find(['0001.txt'])
         self.assertListEqual(msgs, [self.message1])
-        msgs = self.chat.find_messages(['0001.txt', '0002.txt'])
+        msgs = self.chat.msg_find(['0001.txt', '0002.txt'])
         self.assertListEqual(msgs, [self.message1, self.message2])
         # add new Message with full path
         message3 = Message(Question('Question 2'),
                            Answer('Answer 2'),
                            {Tag('btag2')},
                            file_path=pathlib.Path('/foo/bla/0003.txt'))
-        self.chat.add_messages([message3])
+        self.chat.msg_add([message3])
         # find new Message by full path
-        msgs = self.chat.find_messages(['/foo/bla/0003.txt'])
+        msgs = self.chat.msg_find(['/foo/bla/0003.txt'])
         self.assertListEqual(msgs, [message3])
         # find Message with full path only by filename
-        msgs = self.chat.find_messages(['0003.txt'])
+        msgs = self.chat.msg_find(['0003.txt'])
         self.assertListEqual(msgs, [message3])
         # remove last message
-        self.chat.remove_messages(['0003.txt'])
+        self.chat.msg_remove(['0003.txt'])
         self.assertListEqual(self.chat.messages, [self.message1, self.message2])
 
     def test_latest_message(self) -> None:
-        self.assertIsNone(self.chat.latest_message())
-        self.chat.add_messages([self.message1])
-        self.assertEqual(self.chat.latest_message(), self.message1)
-        self.chat.add_messages([self.message2])
-        self.assertEqual(self.chat.latest_message(), self.message2)
+        self.assertIsNone(self.chat.msg_latest())
+        self.chat.msg_add([self.message1])
+        self.assertEqual(self.chat.msg_latest(), self.message1)
+        self.chat.msg_add([self.message2])
+        self.assertEqual(self.chat.msg_latest(), self.message2)
 
     @patch('sys.stdout', new_callable=StringIO)
     def test_print(self, mock_stdout: StringIO) -> None:
-        self.chat.add_messages([self.message1, self.message2])
+        self.chat.msg_add([self.message1, self.message2])
         self.chat.print(paged=False)
         expected_output = f"""{Question.txt_header}
 Question 1
@@ -109,7 +109,7 @@ Answer 2
 
     @patch('sys.stdout', new_callable=StringIO)
     def test_print_with_tags_and_file(self, mock_stdout: StringIO) -> None:
-        self.chat.add_messages([self.message1, self.message2])
+        self.chat.msg_add([self.message1, self.message2])
         self.chat.print(paged=False, with_tags=True, with_files=True)
         expected_output = f"""{TagLine.prefix} atag1 btag2
 FILE: 0001.txt
@@ -267,7 +267,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[3].file_path, pathlib.Path(self.db_path.name, '0004.yaml'))
 
         # write the messages to the cache directory
-        chat_db.write_cache()
+        chat_db.cache_write()
         # check if the written files are in the cache directory
         cache_dir_files = self.message_list(self.cache_path)
         self.assertEqual(len(cache_dir_files), 4)
@@ -287,7 +287,7 @@ class TestChatDB(unittest.TestCase):
         old_timestamps = {file: file.stat().st_mtime for file in db_dir_files}
         # overwrite the messages in the db directory
         time.sleep(0.05)
-        chat_db.write_db()
+        chat_db.db_write()
         # check if the written files are in the DB directory
         db_dir_files = self.message_list(self.db_path)
         self.assertEqual(len(db_dir_files), 4)
@@ -320,7 +320,7 @@ class TestChatDB(unittest.TestCase):
         new_message1.to_file(pathlib.Path(self.db_path.name, '0005.txt'))
         new_message2.to_file(pathlib.Path(self.db_path.name, '0006.yaml'))
         # read and check them
-        chat_db.read_db()
+        chat_db.db_read()
         self.assertEqual(len(chat_db.messages), 6)
         self.assertEqual(chat_db.messages[4].file_path, pathlib.Path(self.db_path.name, '0005.txt'))
         self.assertEqual(chat_db.messages[5].file_path, pathlib.Path(self.db_path.name, '0006.yaml'))
@@ -335,7 +335,7 @@ class TestChatDB(unittest.TestCase):
         new_message3.to_file(pathlib.Path(self.cache_path.name, '0007.txt'))
         new_message4.to_file(pathlib.Path(self.cache_path.name, '0008.yaml'))
         # read and check them
-        chat_db.read_cache()
+        chat_db.cache_read()
         self.assertEqual(len(chat_db.messages), 8)
         # check that the new message have the cache dir path
         self.assertEqual(chat_db.messages[6].file_path, pathlib.Path(self.cache_path.name, '0007.txt'))
@@ -350,7 +350,7 @@ class TestChatDB(unittest.TestCase):
         new_message1.to_file(pathlib.Path(self.db_path.name, '0005.txt'))
         new_message2.to_file(pathlib.Path(self.db_path.name, '0006.yaml'))
         # read from the DB dir and check if the modified messages have been updated
-        chat_db.read_db()
+        chat_db.db_read()
         self.assertEqual(len(chat_db.messages), 8)
         self.assertEqual(chat_db.messages[4].question, 'New Question 1')
         self.assertEqual(chat_db.messages[5].question, 'New Question 2')
@@ -361,7 +361,7 @@ class TestChatDB(unittest.TestCase):
         new_message3.to_file(pathlib.Path(self.db_path.name, '0007.txt'))
         new_message4.to_file(pathlib.Path(self.db_path.name, '0008.yaml'))
         # read and check them
-        chat_db.read_db()
+        chat_db.db_read()
         self.assertEqual(len(chat_db.messages), 8)
         # check that they now have the DB path
         self.assertEqual(chat_db.messages[6].file_path, pathlib.Path(self.db_path.name, '0007.txt'))
@@ -378,13 +378,13 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[3].file_path, pathlib.Path(self.db_path.name, '0004.yaml'))
 
         # write the messages to the cache directory
-        chat_db.write_cache()
+        chat_db.cache_write()
         # check if the written files are in the cache directory
         cache_dir_files = self.message_list(self.cache_path)
         self.assertEqual(len(cache_dir_files), 4)
 
         # now rewrite them to the DB dir and check for modified paths
-        chat_db.write_db()
+        chat_db.db_write()
         db_dir_files = self.message_list(self.db_path)
         self.assertEqual(len(db_dir_files), 4)
         self.assertIn(pathlib.Path(self.db_path.name, '0001.txt'), db_dir_files)
@@ -399,10 +399,10 @@ class TestChatDB(unittest.TestCase):
         message_cache = Message(question=Question("What the hell am I doing here?"),
                                 answer=Answer("You're a creep!"),
                                 file_path=pathlib.Path(self.cache_path.name, '0005.txt'))
-        chat_db.add_messages([message_empty, message_cache])
+        chat_db.msg_add([message_empty, message_cache])
 
         # clear the cache and check the cache dir
-        chat_db.clear_cache()
+        chat_db.cache_clear()
         cache_dir_files = self.message_list(self.cache_path)
         self.assertEqual(len(cache_dir_files), 0)
         # make sure that the DB messages (and the new message) are still there
@@ -423,7 +423,7 @@ class TestChatDB(unittest.TestCase):
         # add new messages to the cache dir
         message1 = Message(question=Question("Question 1"),
                            answer=Answer("Answer 1"))
-        chat_db.add_to_cache([message1])
+        chat_db.cache_add([message1])
         # check if the file_path has been correctly set
         self.assertIsNotNone(message1.file_path)
         self.assertEqual(message1.file_path.parent, pathlib.Path(self.cache_path.name))  # type: ignore [union-attr]
@@ -433,7 +433,7 @@ class TestChatDB(unittest.TestCase):
         # add new messages to the DB dir
         message2 = Message(question=Question("Question 2"),
                            answer=Answer("Answer 2"))
-        chat_db.add_to_db([message2])
+        chat_db.db_add([message2])
         # check if the file_path has been correctly set
         self.assertIsNotNone(message2.file_path)
         self.assertEqual(message2.file_path.parent, pathlib.Path(self.db_path.name))  # type: ignore [union-attr]
@@ -441,7 +441,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(len(db_dir_files), 5)
 
         with self.assertRaises(ChatError):
-            chat_db.add_to_cache([Message(Question("?"), file_path=pathlib.Path("foo"))])
+            chat_db.cache_add([Message(Question("?"), file_path=pathlib.Path("foo"))])
 
     def test_chat_db_write_messages(self) -> None:
         # create a new ChatDB instance
@@ -457,11 +457,11 @@ class TestChatDB(unittest.TestCase):
         message = Message(question=Question("Question 1"),
                           answer=Answer("Answer 1"))
         with self.assertRaises(ChatError):
-            chat_db.write_messages([message])
+            chat_db.msg_write([message])
 
         # write a message with a valid file_path
         message.file_path = pathlib.Path(self.cache_path.name) / '123456.txt'
-        chat_db.write_messages([message])
+        chat_db.msg_write([message])
         cache_dir_files = self.message_list(self.cache_path)
         self.assertEqual(len(cache_dir_files), 1)
         self.assertIn(pathlib.Path(self.cache_path.name, '123456.txt'), cache_dir_files)
@@ -479,37 +479,37 @@ class TestChatDB(unittest.TestCase):
         message = chat_db.messages[0]
         message.answer = Answer("New answer")
         # update message without writing
-        chat_db.update_messages([message], write=False)
+        chat_db.msg_update([message], write=False)
         self.assertEqual(chat_db.messages[0].answer, Answer("New answer"))
         # re-read the message and check for old content
-        chat_db.read_db()
+        chat_db.db_read()
         self.assertEqual(chat_db.messages[0].answer, Answer("Answer 1"))
         # now check with writing (message should be overwritten)
-        chat_db.update_messages([message], write=True)
-        chat_db.read_db()
+        chat_db.msg_update([message], write=True)
+        chat_db.db_read()
         self.assertEqual(chat_db.messages[0].answer, Answer("New answer"))
         # test without file_path -> expect error
         message1 = Message(question=Question("Question 1"),
                            answer=Answer("Answer 1"))
         with self.assertRaises(ChatError):
-            chat_db.update_messages([message1])
+            chat_db.msg_update([message1])
 
     def test_chat_db_latest_message(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
-        self.assertEqual(chat_db.latest_message(source='mem'), self.message4)
-        self.assertEqual(chat_db.latest_message(source='db'), self.message4)
-        self.assertEqual(chat_db.latest_message(source='disk'), self.message4)
-        self.assertEqual(chat_db.latest_message(source='all'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='mem'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='db'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='disk'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='all'), self.message4)
         # the cache is currently empty:
-        self.assertIsNone(chat_db.latest_message(source='cache'))
+        self.assertIsNone(chat_db.msg_latest(source='cache'))
         # add new messages to the cache dir
         new_message = Message(question=Question("New Question"),
                               answer=Answer("New Answer"))
-        chat_db.add_to_cache([new_message])
-        self.assertEqual(chat_db.latest_message(source='cache'), new_message)
-        self.assertEqual(chat_db.latest_message(source='mem'), new_message)
-        self.assertEqual(chat_db.latest_message(source='disk'), new_message)
-        self.assertEqual(chat_db.latest_message(source='all'), new_message)
+        chat_db.cache_add([new_message])
+        self.assertEqual(chat_db.msg_latest(source='cache'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='mem'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='disk'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='all'), new_message)
         # the DB does not contain the new message
-        self.assertEqual(chat_db.latest_message(source='db'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='db'), self.message4)
diff --git a/tests/test_question_cmd.py b/tests/test_question_cmd.py
index b94560f..1c6c958 100644
--- a/tests/test_question_cmd.py
+++ b/tests/test_question_cmd.py
@@ -25,7 +25,7 @@ class TestMessageCreate(unittest.TestCase):
                                     Answer("It is pure text"))
         self.message_code = Message(Question("What is this?"),
                                     Answer("Text\n```\nIt is embedded code\n```\ntext"))
-        self.chat.add_to_db([self.message_text, self.message_code])
+        self.chat.db_add([self.message_text, self.message_code])
         # create arguments mock
         self.args = MagicMock(spec=argparse.Namespace)
         self.args.source_text = None
-- 
2.36.6


From d90845b58b08f888dfa59b2b43d459be6a5f5056 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 09:28:39 +0200
Subject: [PATCH 05/12] chat: added new functions to ChatDB: msg_gather(),
 msg_find(), msg_remove()

---
 chatmastermind/chat.py | 108 ++++++++++++++++++++++++++++++++---------
 1 file changed, 85 insertions(+), 23 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index 8823da4..0aee2fe 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -16,6 +16,7 @@ ChatDBInst = TypeVar('ChatDBInst', bound='ChatDB')
 
 db_next_file = '.next'
 ignored_files = [db_next_file, default_config_file]
+valid_sources = Literal['mem', 'disk', 'cache', 'db', 'all']
 
 
 class ChatError(Exception):
@@ -118,6 +119,16 @@ class Chat:
 
     messages: list[Message]
 
+    def msg_name_matches(self, file_path: Path, name: str) -> bool:
+        """
+        Return True if the given name matches the given file_path.
+        Matching is True if:
+        * 'name' matches the full 'file_path'
+        * 'name' matches 'file_path.name' (i. e. including the suffix)
+        * 'name' matches 'file_path.stem' (i. e. without a suffix)
+        """
+        return Path(name) == file_path or name == file_path.name or name == file_path.stem
+
     def msg_filter(self, mfilter: MessageFilter) -> None:
         """
         Use 'Message.match(mfilter) to remove all messages that
@@ -164,19 +175,19 @@ class Chat:
     def msg_find(self, msg_names: list[str]) -> list[Message]:
         """
         Search and return the messages with the given names. Names can either be filenames
-        (incl. suffixes) or full paths. Messages that can't be found are ignored (i. e. the
-        caller should check the result if he requires all messages).
+        (with or without suffix) or full paths. Messages that can't be found are ignored
+        (i. e. the caller should check the result if they require all messages).
         """
         return [m for m in self.messages
-                if any((m.file_path and (m.file_path == Path(mn) or m.file_path.name == mn)) for mn in msg_names)]
+                if any((m.file_path and self.msg_name_matches(m.file_path, mn)) for mn in msg_names)]
 
     def msg_remove(self, msg_names: list[str]) -> None:
         """
         Remove the messages with the given names. Names can either be filenames
-        (incl. the suffix) or full paths.
+        (with or without suffix) or full paths.
         """
         self.messages = [m for m in self.messages
-                         if not any((m.file_path and (m.file_path == Path(mn) or m.file_path.name == mn)) for mn in msg_names)]
+                         if not any((m.file_path and self.msg_name_matches(m.file_path, mn)) for mn in msg_names)]
         self.msg_sort()
 
     def msg_tags(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> set[Tag]:
@@ -308,8 +319,8 @@ class ChatDB(Chat):
     def msg_update(self, messages: list[Message], write: bool = True) -> None:
         """
         Update EXISTING messages. A message is determined as 'existing' if a message with
-        the same base filename (i. e. 'file_path.name') is already in the list. Only accepts
-        existing messages.
+        the same base filename (i. e. 'file_path.name') is already in the list.
+        Only accepts existing messages.
         """
         if any(not message_in(m, self.messages) for m in messages):
             raise ChatError("Can't update messages that are not in the internal list")
@@ -321,29 +332,80 @@ class ChatDB(Chat):
         if write:
             self.msg_write(messages)
 
-    def msg_latest(self,
-                   mfilter: Optional[MessageFilter] = None,
-                   source: Literal['mem', 'disk', 'cache', 'db', 'all'] = 'mem') -> Optional[Message]:
+    def msg_gather(self,
+                   source: valid_sources,
+                   require_file_path: bool = False,
+                   mfilter: Optional[MessageFilter] = None) -> list[Message]:
         """
-        Return the last added message (according to the file ID) that matches the given filter.
-        Only consider messages with a valid file_path (except if source is 'mem').
-        Searches one of the following sources:
-        * 'mem'  : only search messages currently in memory
-        * 'disk' : search messages on disk (cache + DB directory), but not in memory
-        * 'cache': only search messages in the cache directory
-        * 'db'   : only search messages in the DB directory
-        * 'all'  : search all messages ('mem' + 'disk')
+        Gather and return messages from the given source:
+        * 'mem'  : messages currently in memory
+        * 'disk' : messages on disk (cache + DB directory), but not in memory
+        * 'cache': messages in the cache directory
+        * 'db'   : messages in the DB directory
+        * 'all'  : all messages ('mem' + 'disk')
+
+        If 'require_file_path' is True, return only files with a valid file_path.
         """
         source_messages: list[Message] = []
-        if source == 'mem':
-            return super().msg_latest(mfilter)
+        if source in ['mem', 'all']:
+            if require_file_path:
+                source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
+            else:
+                source_messages += [m for m in self.messages if (mfilter is None or m.match(mfilter))]
         if source in ['cache', 'disk', 'all']:
             source_messages += read_dir(self.cache_path, mfilter=mfilter)
         if source in ['db', 'disk', 'all']:
             source_messages += read_dir(self.db_path, mfilter=mfilter)
-        if source in ['all']:
-            # only consider messages with a valid file_path so they can be sorted
-            source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
+        return source_messages
+
+    def msg_find(self,
+                 msg_names: list[str],
+                 source: valid_sources = 'mem',
+                 ) -> list[Message]:
+        """
+        Search and return the messages with the given names. Names can either be filenames
+        (with or without suffix) or full paths. Messages that can't be found are ignored
+        (i. e. the caller should check the result if they require all messages).
+        Searches one of the following sources:
+        * 'mem'  : messages currently in memory
+        * 'disk' : messages on disk (cache + DB directory), but not in memory
+        * 'cache': messages in the cache directory
+        * 'db'   : messages in the DB directory
+        * 'all'  : all messages ('mem' + 'disk')
+        """
+        source_messages = self.msg_gather(source, require_file_path=True)
+        return [m for m in source_messages
+                if any((m.file_path and self.msg_name_matches(m.file_path, mn)) for mn in msg_names)]
+
+    def msg_remove(self, msg_names: list[str]) -> None:
+        """
+        Remove the messages with the given names. Names can either be filenames
+        (with or without suffix) or full paths. Also deletes the files of all given
+        messages with a valid file_path.
+        """
+        # delete the message files first
+        rm_messages = self.msg_find(msg_names, source='all')
+        for m in rm_messages:
+            if (m.file_path):
+                m.file_path.unlink()
+        # then remove them from the internal list
+        super().msg_remove(msg_names)
+
+    def msg_latest(self,
+                   mfilter: Optional[MessageFilter] = None,
+                   source: valid_sources = 'mem') -> Optional[Message]:
+        """
+        Return the last added message (according to the file ID) that matches the given filter.
+        Only consider messages with a valid file_path (except if source is 'mem').
+        Searches one of the following sources:
+        * 'mem'  : messages currently in memory
+        * 'disk' : messages on disk (cache + DB directory), but not in memory
+        * 'cache': messages in the cache directory
+        * 'db'   : messages in the DB directory
+        * 'all'  : all messages ('mem' + 'disk')
+        """
+        # only consider messages with a valid file_path so they can be sorted
+        source_messages = self.msg_gather(source, require_file_path=True)
         source_messages.sort(key=lambda m: m.msg_id(), reverse=True)
         for m in source_messages:
             if mfilter is None or m.match(mfilter):
-- 
2.36.6


From fc82f85b7ce469ffffc26fb4b5a43dd4abc056fb Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 10:17:20 +0200
Subject: [PATCH 06/12] chat: added new functions: msg_unique_id(),
 msg_unique_content() and tests

---
 chatmastermind/chat.py | 29 ++++++++++++++++-
 tests/test_chat.py     | 73 +++++++++++++++++++++++++++++++++---------
 2 files changed, 86 insertions(+), 16 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index 0aee2fe..083b91e 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -146,6 +146,25 @@ class Chat:
         except MessageError:
             pass
 
+    def msg_unique_id(self) -> None:
+        """
+        Remove duplicates from the internal messages, based on the msg_id (i. e. file_path).
+        Messages without a file_path are kept.
+        """
+        old_msgs = self.messages.copy()
+        self.messages = []
+        for m in old_msgs:
+            if not message_in(m, self.messages):
+                self.messages.append(m)
+        self.msg_sort()
+
+    def msg_unique_content(self) -> None:
+        """
+        Remove duplicates from the internal messages, based on the content (i. e. question + answer).
+        """
+        self.messages = list(set(self.messages))
+        self.msg_sort()
+
     def msg_clear(self) -> None:
         """
         Delete all messages.
@@ -356,7 +375,13 @@ class ChatDB(Chat):
             source_messages += read_dir(self.cache_path, mfilter=mfilter)
         if source in ['db', 'disk', 'all']:
             source_messages += read_dir(self.db_path, mfilter=mfilter)
-        return source_messages
+        # remove_duplicates and sort the list
+        unique_messages: list[Message] = []
+        for m in source_messages:
+            if not message_in(m, unique_messages):
+                unique_messages.append(m)
+        unique_messages.sort(key=lambda m: m.msg_id())
+        return unique_messages
 
     def msg_find(self,
                  msg_names: list[str],
@@ -430,6 +455,7 @@ class ChatDB(Chat):
         Write messages to the cache directory. If a message has no file_path, a new one
         will be created. If message.file_path exists, it will be modified to point to
         the cache directory.
+        Does NOT add the messages to the internal list (use 'cache_add()' for that)!
         """
         write_dir(self.cache_path,
                   messages if messages else self.messages,
@@ -480,6 +506,7 @@ class ChatDB(Chat):
         Write messages to the DB directory. If a message has no file_path, a new one
         will be created. If message.file_path exists, it will be modified to point
         to the DB directory.
+        Does NOT add the messages to the internal list (use 'db_add()' for that)!
         """
         write_dir(self.db_path,
                   messages if messages else self.messages,
diff --git a/tests/test_chat.py b/tests/test_chat.py
index 6aac1b5..7ea5b0c 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -21,6 +21,29 @@ class TestChat(unittest.TestCase):
                                 Answer('Answer 2'),
                                 {Tag('btag2')},
                                 file_path=pathlib.Path('0002.txt'))
+        self.maxDiff = None
+
+    def test_unique_id(self) -> None:
+        # test with two identical messages
+        self.chat.msg_add([self.message1, self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message1])
+        self.chat.msg_unique_id()
+        self.assertSequenceEqual(self.chat.messages, [self.message1])
+        # test with two different messages
+        self.chat.msg_add([self.message2])
+        self.chat.msg_unique_id()
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message2])
+
+    def test_unique_content(self) -> None:
+        # test with two identical messages
+        self.chat.msg_add([self.message1, self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message1])
+        self.chat.msg_unique_content()
+        self.assertSequenceEqual(self.chat.messages, [self.message1])
+        # test with two different messages
+        self.chat.msg_add([self.message2])
+        self.chat.msg_unique_content()
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message2])
 
     def test_filter(self) -> None:
         self.chat.msg_add([self.message1, self.message2])
@@ -166,7 +189,6 @@ class TestChatDB(unittest.TestCase):
         with open(pathlib.Path(self.db_path.name) / 'content.yaml', 'w') as f:
             yaml.dump({'key': 'value'}, f)
         self.trash_files.append('content.yaml')
-
         self.maxDiff = None
 
     def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[pathlib.Path]:
@@ -181,7 +203,7 @@ class TestChatDB(unittest.TestCase):
         self.cache_path.cleanup()
         pass
 
-    def test_chat_db_from_dir(self) -> None:
+    def test_from_dir(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
         self.assertEqual(len(chat_db.messages), 4)
@@ -197,7 +219,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[3].file_path,
                          pathlib.Path(self.db_path.name, '0004.yaml'))
 
-    def test_chat_db_from_dir_glob(self) -> None:
+    def test_from_dir_glob(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name),
                                   glob='*.txt')
@@ -209,7 +231,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[1].file_path,
                          pathlib.Path(self.db_path.name, '0003.txt'))
 
-    def test_chat_db_from_dir_filter_tags(self) -> None:
+    def test_from_dir_filter_tags(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name),
                                   mfilter=MessageFilter(tags_or={Tag('tag1')}))
@@ -219,7 +241,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[0].file_path,
                          pathlib.Path(self.db_path.name, '0001.txt'))
 
-    def test_chat_db_from_dir_filter_tags_empty(self) -> None:
+    def test_from_dir_filter_tags_empty(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name),
                                   mfilter=MessageFilter(tags_or=set(),
@@ -227,7 +249,7 @@ class TestChatDB(unittest.TestCase):
                                                         tags_not=set()))
         self.assertEqual(len(chat_db.messages), 0)
 
-    def test_chat_db_from_dir_filter_answer(self) -> None:
+    def test_from_dir_filter_answer(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name),
                                   mfilter=MessageFilter(answer_contains='Answer 2'))
@@ -238,7 +260,7 @@ class TestChatDB(unittest.TestCase):
                          pathlib.Path(self.db_path.name, '0002.yaml'))
         self.assertEqual(chat_db.messages[0].answer, 'Answer 2')
 
-    def test_chat_db_from_messages(self) -> None:
+    def test_from_messages(self) -> None:
         chat_db = ChatDB.from_messages(pathlib.Path(self.cache_path.name),
                                        pathlib.Path(self.db_path.name),
                                        messages=[self.message1, self.message2,
@@ -247,7 +269,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.cache_path, pathlib.Path(self.cache_path.name))
         self.assertEqual(chat_db.db_path, pathlib.Path(self.db_path.name))
 
-    def test_chat_db_fids(self) -> None:
+    def test_fids(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
         self.assertEqual(chat_db.get_next_fid(), 5)
@@ -256,7 +278,7 @@ class TestChatDB(unittest.TestCase):
         with open(chat_db.next_path, 'r') as f:
             self.assertEqual(f.read(), '7')
 
-    def test_chat_db_write(self) -> None:
+    def test_db_write(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
@@ -304,7 +326,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[2].file_path, pathlib.Path(self.db_path.name, '0003.txt'))
         self.assertEqual(chat_db.messages[3].file_path, pathlib.Path(self.db_path.name, '0004.yaml'))
 
-    def test_chat_db_read(self) -> None:
+    def test_db_read(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
@@ -367,7 +389,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[6].file_path, pathlib.Path(self.db_path.name, '0007.txt'))
         self.assertEqual(chat_db.messages[7].file_path, pathlib.Path(self.db_path.name, '0008.yaml'))
 
-    def test_chat_db_clear(self) -> None:
+    def test_cache_clear(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
@@ -412,7 +434,7 @@ class TestChatDB(unittest.TestCase):
         # but not the message with the cache dir path
         self.assertFalse(any(m.file_path == message_cache.file_path for m in chat_db.messages))
 
-    def test_chat_db_add(self) -> None:
+    def test_add(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
@@ -443,7 +465,7 @@ class TestChatDB(unittest.TestCase):
         with self.assertRaises(ChatError):
             chat_db.cache_add([Message(Question("?"), file_path=pathlib.Path("foo"))])
 
-    def test_chat_db_write_messages(self) -> None:
+    def test_msg_write(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
@@ -466,7 +488,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(len(cache_dir_files), 1)
         self.assertIn(pathlib.Path(self.cache_path.name, '123456.txt'), cache_dir_files)
 
-    def test_chat_db_update_messages(self) -> None:
+    def test_msg_update(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
@@ -494,7 +516,28 @@ class TestChatDB(unittest.TestCase):
         with self.assertRaises(ChatError):
             chat_db.msg_update([message1])
 
-    def test_chat_db_latest_message(self) -> None:
+    def test_msg_find(self) -> None:
+        chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
+                                  pathlib.Path(self.db_path.name))
+        # search for a DB file in memory
+        self.assertEqual(chat_db.msg_find([str(self.message1.file_path)], source='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find(['0001.txt'], source='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find(['0001'], source='mem'), [self.message1])
+        # and on disk
+        self.assertEqual(chat_db.msg_find([str(self.message2.file_path)], source='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find(['0002.yaml'], source='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find(['0002'], source='db'), [self.message2])
+        # now search the cache -> expect empty result
+        self.assertEqual(chat_db.msg_find([str(self.message3.file_path)], source='cache'), [])
+        self.assertEqual(chat_db.msg_find(['0003.txt'], source='cache'), [])
+        self.assertEqual(chat_db.msg_find(['0003'], source='cache'), [])
+        # search for multiple messages
+        search_names = ['0001', '0002.yaml', str(self.message3.file_path)]
+        expected_result = [self.message1, self.message2, self.message3]
+        result = chat_db.msg_find(search_names, source='all')
+        self.assertSequenceEqual(result, expected_result)
+
+    def test_msg_latest(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
         self.assertEqual(chat_db.msg_latest(source='mem'), self.message4)
-- 
2.36.6


From 525cdb92a19cbfca6c5f980b6276b8bd15e9399e Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 12:20:41 +0200
Subject: [PATCH 07/12] message / chat: 'msg_id()' now returns 'file_path.stem'
 (removed suffix)

---
 chatmastermind/chat.py    | 28 +++++++++++++++-------------
 chatmastermind/message.py |  5 +++--
 tests/test_chat.py        |  6 +++++-
 tests/test_message.py     |  2 +-
 4 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index 083b91e..41d12b9 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -16,7 +16,7 @@ ChatDBInst = TypeVar('ChatDBInst', bound='ChatDB')
 
 db_next_file = '.next'
 ignored_files = [db_next_file, default_config_file]
-valid_sources = Literal['mem', 'disk', 'cache', 'db', 'all']
+msg_place = Literal['mem', 'disk', 'cache', 'db', 'all']
 
 
 class ChatError(Exception):
@@ -194,8 +194,9 @@ class Chat:
     def msg_find(self, msg_names: list[str]) -> list[Message]:
         """
         Search and return the messages with the given names. Names can either be filenames
-        (with or without suffix) or full paths. Messages that can't be found are ignored
-        (i. e. the caller should check the result if they require all messages).
+        (with or without suffix), full paths or Message.msg_id(). Messages that can't be
+        found are ignored (i. e. the caller should check the result if they require all
+        messages).
         """
         return [m for m in self.messages
                 if any((m.file_path and self.msg_name_matches(m.file_path, mn)) for mn in msg_names)]
@@ -203,7 +204,7 @@ class Chat:
     def msg_remove(self, msg_names: list[str]) -> None:
         """
         Remove the messages with the given names. Names can either be filenames
-        (with or without suffix) or full paths.
+        (with or without suffix), full paths or Message.msg_id().
         """
         self.messages = [m for m in self.messages
                          if not any((m.file_path and self.msg_name_matches(m.file_path, mn)) for mn in msg_names)]
@@ -352,7 +353,7 @@ class ChatDB(Chat):
             self.msg_write(messages)
 
     def msg_gather(self,
-                   source: valid_sources,
+                   source: msg_place,
                    require_file_path: bool = False,
                    mfilter: Optional[MessageFilter] = None) -> list[Message]:
         """
@@ -385,13 +386,14 @@ class ChatDB(Chat):
 
     def msg_find(self,
                  msg_names: list[str],
-                 source: valid_sources = 'mem',
+                 source: msg_place = 'mem',
                  ) -> list[Message]:
         """
         Search and return the messages with the given names. Names can either be filenames
-        (with or without suffix) or full paths. Messages that can't be found are ignored
-        (i. e. the caller should check the result if they require all messages).
-        Searches one of the following sources:
+        (with or without suffix), full paths or Message.msg_id(). Messages that can't be
+        found are ignored (i. e. the caller should check the result if they require all
+        messages).
+        Searches one of the following places:
         * 'mem'  : messages currently in memory
         * 'disk' : messages on disk (cache + DB directory), but not in memory
         * 'cache': messages in the cache directory
@@ -405,8 +407,8 @@ class ChatDB(Chat):
     def msg_remove(self, msg_names: list[str]) -> None:
         """
         Remove the messages with the given names. Names can either be filenames
-        (with or without suffix) or full paths. Also deletes the files of all given
-        messages with a valid file_path.
+        (with or without suffix), full paths or Message.msg_id(). Also deletes the
+        files of all given messages with a valid file_path.
         """
         # delete the message files first
         rm_messages = self.msg_find(msg_names, source='all')
@@ -418,11 +420,11 @@ class ChatDB(Chat):
 
     def msg_latest(self,
                    mfilter: Optional[MessageFilter] = None,
-                   source: valid_sources = 'mem') -> Optional[Message]:
+                   source: msg_place = 'mem') -> Optional[Message]:
         """
         Return the last added message (according to the file ID) that matches the given filter.
         Only consider messages with a valid file_path (except if source is 'mem').
-        Searches one of the following sources:
+        Searches one of the following places:
         * 'mem'  : messages currently in memory
         * 'disk' : messages on disk (cache + DB directory), but not in memory
         * 'cache': messages in the cache directory
diff --git a/chatmastermind/message.py b/chatmastermind/message.py
index 402a6d1..498de88 100644
--- a/chatmastermind/message.py
+++ b/chatmastermind/message.py
@@ -543,10 +543,11 @@ class Message():
     def msg_id(self) -> str:
         """
         Returns an ID that is unique throughout all messages in the same (DB) directory.
-        Currently this is the file name. The ID is also used for sorting messages.
+        Currently this is the file name without suffix. The ID is also used for sorting
+        messages.
         """
         if self.file_path:
-            return self.file_path.name
+            return self.file_path.stem
         else:
             raise MessageError("Can't create file ID without a file path")
 
diff --git a/tests/test_chat.py b/tests/test_chat.py
index 7ea5b0c..9b94607 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -521,18 +521,22 @@ class TestChatDB(unittest.TestCase):
                                   pathlib.Path(self.db_path.name))
         # search for a DB file in memory
         self.assertEqual(chat_db.msg_find([str(self.message1.file_path)], source='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find([self.message1.msg_id()], source='mem'), [self.message1])
         self.assertEqual(chat_db.msg_find(['0001.txt'], source='mem'), [self.message1])
         self.assertEqual(chat_db.msg_find(['0001'], source='mem'), [self.message1])
         # and on disk
         self.assertEqual(chat_db.msg_find([str(self.message2.file_path)], source='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find([self.message2.msg_id()], source='db'), [self.message2])
         self.assertEqual(chat_db.msg_find(['0002.yaml'], source='db'), [self.message2])
         self.assertEqual(chat_db.msg_find(['0002'], source='db'), [self.message2])
         # now search the cache -> expect empty result
         self.assertEqual(chat_db.msg_find([str(self.message3.file_path)], source='cache'), [])
+        self.assertEqual(chat_db.msg_find([self.message3.msg_id()], source='cache'), [])
         self.assertEqual(chat_db.msg_find(['0003.txt'], source='cache'), [])
         self.assertEqual(chat_db.msg_find(['0003'], source='cache'), [])
         # search for multiple messages
-        search_names = ['0001', '0002.yaml', str(self.message3.file_path)]
+        # -> search one twice, expect result to be unique
+        search_names = ['0001', '0002.yaml', self.message3.msg_id(), str(self.message3.file_path)]
         expected_result = [self.message1, self.message2, self.message3]
         result = chat_db.msg_find(search_names, source='all')
         self.assertSequenceEqual(result, expected_result)
diff --git a/tests/test_message.py b/tests/test_message.py
index 1f440df..5c7997f 100644
--- a/tests/test_message.py
+++ b/tests/test_message.py
@@ -730,7 +730,7 @@ class MessageIDTestCase(unittest.TestCase):
         self.file_path.unlink()
 
     def test_msg_id_txt(self) -> None:
-        self.assertEqual(self.message.msg_id(), self.file_path.name)
+        self.assertEqual(self.message.msg_id(), self.file_path.stem)
 
     def test_msg_id_txt_exception(self) -> None:
         with self.assertRaises(MessageError):
-- 
2.36.6


From f6a6e6036b7fa6e061658f60f6bb1e8ce356fb50 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 14:41:42 +0200
Subject: [PATCH 08/12] chat: added validation during initialization

---
 chatmastermind/chat.py | 20 ++++++++++++++++++++
 tests/test_chat.py     | 11 +++++++++++
 2 files changed, 31 insertions(+)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index 41d12b9..fdfc3d3 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -119,6 +119,25 @@ class Chat:
 
     messages: list[Message]
 
+    def __post_init__(self) -> None:
+        self.validate()
+
+    def validate(self) -> None:
+        """
+        Validate this Chat instance.
+        """
+        def msg_paths(stem: str) -> list[str]:
+            return [str(fp) for fp in file_paths if fp.stem == stem]
+        file_paths: set[Path] = {m.file_path for m in self.messages if m.file_path is not None}
+        file_stems = [m.file_path.stem for m in self.messages if m.file_path is not None]
+        error = False
+        for fp in file_paths:
+            if file_stems.count(fp.stem) > 1:
+                print(f"ERROR: Found multiple copies of message '{fp.stem}': {msg_paths(fp.stem)}")
+                error = True
+        if error:
+            raise ChatError("Validation failed")
+
     def msg_name_matches(self, file_path: Path, name: str) -> bool:
         """
         Return True if the given name matches the given file_path.
@@ -276,6 +295,7 @@ class ChatDB(Chat):
         # make all paths absolute
         self.cache_path = self.cache_path.absolute()
         self.db_path = self.db_path.absolute()
+        self.validate()
 
     @classmethod
     def from_dir(cls: Type[ChatDBInst],
diff --git a/tests/test_chat.py b/tests/test_chat.py
index 9b94607..82992ee 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -203,6 +203,17 @@ class TestChatDB(unittest.TestCase):
         self.cache_path.cleanup()
         pass
 
+    def test_validate(self) -> None:
+        duplicate_message = Message(Question('Question 4'),
+                                    Answer('Answer 4'),
+                                    {Tag('tag4')},
+                                    file_path=pathlib.Path('0004.txt'))
+        duplicate_message.to_file(pathlib.Path(self.db_path.name, '0004.txt'))
+        with self.assertRaises(ChatError) as cm:
+            ChatDB.from_dir(pathlib.Path(self.cache_path.name),
+                            pathlib.Path(self.db_path.name))
+        self.assertEqual(str(cm.exception), "Validation failed")
+
     def test_from_dir(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
-- 
2.36.6


From 33ae27f00e01f6fd8259aedd1dae0fe5ad0992bd Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 16:00:05 +0200
Subject: [PATCH 09/12] chat: msg_remove() now supports multiple locations

---
 chatmastermind/chat.py | 63 +++++++++++++++++++++++-------------------
 tests/test_chat.py     | 46 +++++++++++++++---------------
 2 files changed, 58 insertions(+), 51 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index fdfc3d3..cb4855e 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -16,7 +16,7 @@ ChatDBInst = TypeVar('ChatDBInst', bound='ChatDB')
 
 db_next_file = '.next'
 ignored_files = [db_next_file, default_config_file]
-msg_place = Literal['mem', 'disk', 'cache', 'db', 'all']
+msg_location = Literal['mem', 'disk', 'cache', 'db', 'all']
 
 
 class ChatError(Exception):
@@ -373,11 +373,11 @@ class ChatDB(Chat):
             self.msg_write(messages)
 
     def msg_gather(self,
-                   source: msg_place,
+                   loc: msg_location,
                    require_file_path: bool = False,
                    mfilter: Optional[MessageFilter] = None) -> list[Message]:
         """
-        Gather and return messages from the given source:
+        Gather and return messages from the given locations:
         * 'mem'  : messages currently in memory
         * 'disk' : messages on disk (cache + DB directory), but not in memory
         * 'cache': messages in the cache directory
@@ -386,19 +386,19 @@ class ChatDB(Chat):
 
         If 'require_file_path' is True, return only files with a valid file_path.
         """
-        source_messages: list[Message] = []
-        if source in ['mem', 'all']:
+        loc_messages: list[Message] = []
+        if loc in ['mem', 'all']:
             if require_file_path:
-                source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
+                loc_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
             else:
-                source_messages += [m for m in self.messages if (mfilter is None or m.match(mfilter))]
-        if source in ['cache', 'disk', 'all']:
-            source_messages += read_dir(self.cache_path, mfilter=mfilter)
-        if source in ['db', 'disk', 'all']:
-            source_messages += read_dir(self.db_path, mfilter=mfilter)
+                loc_messages += [m for m in self.messages if (mfilter is None or m.match(mfilter))]
+        if loc in ['cache', 'disk', 'all']:
+            loc_messages += read_dir(self.cache_path, mfilter=mfilter)
+        if loc in ['db', 'disk', 'all']:
+            loc_messages += read_dir(self.db_path, mfilter=mfilter)
         # remove_duplicates and sort the list
         unique_messages: list[Message] = []
-        for m in source_messages:
+        for m in loc_messages:
             if not message_in(m, unique_messages):
                 unique_messages.append(m)
         unique_messages.sort(key=lambda m: m.msg_id())
@@ -406,45 +406,52 @@ class ChatDB(Chat):
 
     def msg_find(self,
                  msg_names: list[str],
-                 source: msg_place = 'mem',
+                 loc: msg_location = 'mem',
                  ) -> list[Message]:
         """
         Search and return the messages with the given names. Names can either be filenames
         (with or without suffix), full paths or Message.msg_id(). Messages that can't be
         found are ignored (i. e. the caller should check the result if they require all
         messages).
-        Searches one of the following places:
+        Searches one of the following locations:
         * 'mem'  : messages currently in memory
         * 'disk' : messages on disk (cache + DB directory), but not in memory
         * 'cache': messages in the cache directory
         * 'db'   : messages in the DB directory
         * 'all'  : all messages ('mem' + 'disk')
         """
-        source_messages = self.msg_gather(source, require_file_path=True)
-        return [m for m in source_messages
+        loc_messages = self.msg_gather(loc, require_file_path=True)
+        return [m for m in loc_messages
                 if any((m.file_path and self.msg_name_matches(m.file_path, mn)) for mn in msg_names)]
 
-    def msg_remove(self, msg_names: list[str]) -> None:
+    def msg_remove(self, msg_names: list[str], loc: msg_location = 'mem') -> None:
         """
         Remove the messages with the given names. Names can either be filenames
         (with or without suffix), full paths or Message.msg_id(). Also deletes the
         files of all given messages with a valid file_path.
+        Delete files from one of the following locations:
+        * 'mem'  : messages currently in memory
+        * 'disk' : messages on disk (cache + DB directory), but not in memory
+        * 'cache': messages in the cache directory
+        * 'db'   : messages in the DB directory
+        * 'all'  : all messages ('mem' + 'disk')
         """
-        # delete the message files first
-        rm_messages = self.msg_find(msg_names, source='all')
-        for m in rm_messages:
-            if (m.file_path):
-                m.file_path.unlink()
+        if loc != 'mem':
+            # delete the message files first
+            rm_messages = self.msg_find(msg_names, loc=loc)
+            for m in rm_messages:
+                if (m.file_path):
+                    m.file_path.unlink()
         # then remove them from the internal list
         super().msg_remove(msg_names)
 
     def msg_latest(self,
                    mfilter: Optional[MessageFilter] = None,
-                   source: msg_place = 'mem') -> Optional[Message]:
+                   loc: msg_location = 'mem') -> Optional[Message]:
         """
         Return the last added message (according to the file ID) that matches the given filter.
-        Only consider messages with a valid file_path (except if source is 'mem').
-        Searches one of the following places:
+        Only consider messages with a valid file_path (except if loc is 'mem').
+        Searches one of the following locations:
         * 'mem'  : messages currently in memory
         * 'disk' : messages on disk (cache + DB directory), but not in memory
         * 'cache': messages in the cache directory
@@ -452,9 +459,9 @@ class ChatDB(Chat):
         * 'all'  : all messages ('mem' + 'disk')
         """
         # only consider messages with a valid file_path so they can be sorted
-        source_messages = self.msg_gather(source, require_file_path=True)
-        source_messages.sort(key=lambda m: m.msg_id(), reverse=True)
-        for m in source_messages:
+        loc_messages = self.msg_gather(loc, require_file_path=True)
+        loc_messages.sort(key=lambda m: m.msg_id(), reverse=True)
+        for m in loc_messages:
             if mfilter is None or m.match(mfilter):
                 return m
         return None
diff --git a/tests/test_chat.py b/tests/test_chat.py
index 82992ee..d3b5c8d 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -531,43 +531,43 @@ class TestChatDB(unittest.TestCase):
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
         # search for a DB file in memory
-        self.assertEqual(chat_db.msg_find([str(self.message1.file_path)], source='mem'), [self.message1])
-        self.assertEqual(chat_db.msg_find([self.message1.msg_id()], source='mem'), [self.message1])
-        self.assertEqual(chat_db.msg_find(['0001.txt'], source='mem'), [self.message1])
-        self.assertEqual(chat_db.msg_find(['0001'], source='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find([str(self.message1.file_path)], loc='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find([self.message1.msg_id()], loc='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find(['0001.txt'], loc='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find(['0001'], loc='mem'), [self.message1])
         # and on disk
-        self.assertEqual(chat_db.msg_find([str(self.message2.file_path)], source='db'), [self.message2])
-        self.assertEqual(chat_db.msg_find([self.message2.msg_id()], source='db'), [self.message2])
-        self.assertEqual(chat_db.msg_find(['0002.yaml'], source='db'), [self.message2])
-        self.assertEqual(chat_db.msg_find(['0002'], source='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find([str(self.message2.file_path)], loc='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find([self.message2.msg_id()], loc='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find(['0002.yaml'], loc='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find(['0002'], loc='db'), [self.message2])
         # now search the cache -> expect empty result
-        self.assertEqual(chat_db.msg_find([str(self.message3.file_path)], source='cache'), [])
-        self.assertEqual(chat_db.msg_find([self.message3.msg_id()], source='cache'), [])
-        self.assertEqual(chat_db.msg_find(['0003.txt'], source='cache'), [])
-        self.assertEqual(chat_db.msg_find(['0003'], source='cache'), [])
+        self.assertEqual(chat_db.msg_find([str(self.message3.file_path)], loc='cache'), [])
+        self.assertEqual(chat_db.msg_find([self.message3.msg_id()], loc='cache'), [])
+        self.assertEqual(chat_db.msg_find(['0003.txt'], loc='cache'), [])
+        self.assertEqual(chat_db.msg_find(['0003'], loc='cache'), [])
         # search for multiple messages
         # -> search one twice, expect result to be unique
         search_names = ['0001', '0002.yaml', self.message3.msg_id(), str(self.message3.file_path)]
         expected_result = [self.message1, self.message2, self.message3]
-        result = chat_db.msg_find(search_names, source='all')
+        result = chat_db.msg_find(search_names, loc='all')
         self.assertSequenceEqual(result, expected_result)
 
     def test_msg_latest(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
-        self.assertEqual(chat_db.msg_latest(source='mem'), self.message4)
-        self.assertEqual(chat_db.msg_latest(source='db'), self.message4)
-        self.assertEqual(chat_db.msg_latest(source='disk'), self.message4)
-        self.assertEqual(chat_db.msg_latest(source='all'), self.message4)
+        self.assertEqual(chat_db.msg_latest(loc='mem'), self.message4)
+        self.assertEqual(chat_db.msg_latest(loc='db'), self.message4)
+        self.assertEqual(chat_db.msg_latest(loc='disk'), self.message4)
+        self.assertEqual(chat_db.msg_latest(loc='all'), self.message4)
         # the cache is currently empty:
-        self.assertIsNone(chat_db.msg_latest(source='cache'))
+        self.assertIsNone(chat_db.msg_latest(loc='cache'))
         # add new messages to the cache dir
         new_message = Message(question=Question("New Question"),
                               answer=Answer("New Answer"))
         chat_db.cache_add([new_message])
-        self.assertEqual(chat_db.msg_latest(source='cache'), new_message)
-        self.assertEqual(chat_db.msg_latest(source='mem'), new_message)
-        self.assertEqual(chat_db.msg_latest(source='disk'), new_message)
-        self.assertEqual(chat_db.msg_latest(source='all'), new_message)
+        self.assertEqual(chat_db.msg_latest(loc='cache'), new_message)
+        self.assertEqual(chat_db.msg_latest(loc='mem'), new_message)
+        self.assertEqual(chat_db.msg_latest(loc='disk'), new_message)
+        self.assertEqual(chat_db.msg_latest(loc='all'), new_message)
         # the DB does not contain the new message
-        self.assertEqual(chat_db.msg_latest(source='db'), self.message4)
+        self.assertEqual(chat_db.msg_latest(loc='db'), self.message4)
-- 
2.36.6


From 2fb7410b4397d5a7e5286a89e0abcd8d0928106d Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Fri, 15 Sep 2023 22:42:11 +0200
Subject: [PATCH 10/12] chat: added functions msg_in_cache() and msg_in_db(),
 also tests

---
 chatmastermind/chat.py | 26 +++++++++++++++++++++++++-
 tests/test_chat.py     | 19 +++++++++++++++++++
 2 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index cb4855e..f030c5e 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -6,7 +6,7 @@ from pathlib import Path
 from pprint import PrettyPrinter
 from pydoc import pager
 from dataclasses import dataclass
-from typing import TypeVar, Type, Optional, ClassVar, Any, Callable, Literal
+from typing import TypeVar, Type, Optional, ClassVar, Any, Callable, Literal, Union
 from .configuration import default_config_file
 from .message import Message, MessageFilter, MessageError, message_in
 from .tags import Tag
@@ -466,6 +466,30 @@ class ChatDB(Chat):
                 return m
         return None
 
+    def msg_in_cache(self, message: Union[Message, str]) -> bool:
+        """
+        Return true if the given Message (or filename or Message.msg_id())
+        is located in the cache directory. False otherwise.
+        """
+        if isinstance(message, Message):
+            return (message.file_path is not None
+                    and message.file_path.parent.samefile(self.cache_path)  # noqa: W503
+                    and message.file_path.exists())  # noqa: W503
+        else:
+            return len(self.msg_find([message], loc='cache')) > 0
+
+    def msg_in_db(self, message: Union[Message, str]) -> bool:
+        """
+        Return true if the given Message (or filename or Message.msg_id())
+        is located in the DB directory. False otherwise.
+        """
+        if isinstance(message, Message):
+            return (message.file_path is not None
+                    and message.file_path.parent.samefile(self.db_path)  # noqa: W503
+                    and message.file_path.exists())  # noqa: W503
+        else:
+            return len(self.msg_find([message], loc='db')) > 0
+
     def cache_read(self) -> None:
         """
         Read messages from the cache directory. New ones are added to the internal list,
diff --git a/tests/test_chat.py b/tests/test_chat.py
index d3b5c8d..e2150ff 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -289,6 +289,25 @@ class TestChatDB(unittest.TestCase):
         with open(chat_db.next_path, 'r') as f:
             self.assertEqual(f.read(), '7')
 
+    def test_msg_in_db_or_cache(self) -> None:
+        # create a new ChatDB instance
+        chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
+                                  pathlib.Path(self.db_path.name))
+        self.assertTrue(chat_db.msg_in_db(self.message1))
+        self.assertTrue(chat_db.msg_in_db(str(self.message1.file_path)))
+        self.assertTrue(chat_db.msg_in_db(self.message1.msg_id()))
+        self.assertFalse(chat_db.msg_in_cache(self.message1))
+        self.assertFalse(chat_db.msg_in_cache(str(self.message1.file_path)))
+        self.assertFalse(chat_db.msg_in_cache(self.message1.msg_id()))
+        # add new message to the cache dir
+        cache_message = Message(question=Question("Question 1"),
+                                answer=Answer("Answer 1"))
+        chat_db.cache_add([cache_message])
+        self.assertTrue(chat_db.msg_in_cache(cache_message))
+        self.assertTrue(chat_db.msg_in_cache(cache_message.msg_id()))
+        self.assertFalse(chat_db.msg_in_db(cache_message))
+        self.assertFalse(chat_db.msg_in_db(str(cache_message.file_path)))
+
     def test_db_write(self) -> None:
         # create a new ChatDB instance
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
-- 
2.36.6


From cf572e1882a79e9bd63cf132ffc865ad3f396a96 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Sat, 16 Sep 2023 19:52:53 +0200
Subject: [PATCH 11/12] chat: added functions db_move() and chat_move() (and
 tests)

---
 chatmastermind/chat.py | 38 +++++++++++++++++++++++++++++++-
 tests/test_chat.py     | 49 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 1 deletion(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index f030c5e..06895ac 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -401,7 +401,11 @@ class ChatDB(Chat):
         for m in loc_messages:
             if not message_in(m, unique_messages):
                 unique_messages.append(m)
-        unique_messages.sort(key=lambda m: m.msg_id())
+        try:
+            unique_messages.sort(key=lambda m: m.msg_id())
+        # messages in 'mem' can have an empty file_path
+        except MessageError:
+            pass
         return unique_messages
 
     def msg_find(self,
@@ -541,6 +545,22 @@ class ChatDB(Chat):
         # only keep messages from DB dir (or those that have not yet been written)
         self.messages = [m for m in self.messages if not m.file_path or m.file_path.parent.samefile(self.db_path)]
 
+    def cache_move(self, message: Message) -> None:
+        """
+        Moves the given messages to the cache directory.
+        """
+        # remember the old path (if any)
+        old_path: Optional[Path] = None
+        if message.file_path:
+            old_path = message.file_path
+        # write message to the new destination
+        self.cache_write([message])
+        # remove the old one (if any)
+        if old_path:
+            self.msg_remove([str(old_path)], loc='db')
+        # (re)add it to the internal list
+        self.msg_add([message])
+
     def db_read(self) -> None:
         """
         Read messages from the DB directory. New ones are added to the internal list,
@@ -583,3 +603,19 @@ class ChatDB(Chat):
                 m.file_path = make_file_path(self.db_path, self.default_file_suffix, self.get_next_fid)
         self.messages += messages
         self.msg_sort()
+
+    def db_move(self, message: Message) -> None:
+        """
+        Moves the given messages to the db directory.
+        """
+        # remember the old path (if any)
+        old_path: Optional[Path] = None
+        if message.file_path:
+            old_path = message.file_path
+        # write message to the new destination
+        self.db_write([message])
+        # remove the old one (if any)
+        if old_path:
+            self.msg_remove([str(old_path)], loc='cache')
+        # (re)add it to the internal list
+        self.msg_add([message])
diff --git a/tests/test_chat.py b/tests/test_chat.py
index e2150ff..4558e4d 100644
--- a/tests/test_chat.py
+++ b/tests/test_chat.py
@@ -590,3 +590,52 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.msg_latest(loc='all'), new_message)
         # the DB does not contain the new message
         self.assertEqual(chat_db.msg_latest(loc='db'), self.message4)
+
+    def test_msg_gather(self) -> None:
+        chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
+                                  pathlib.Path(self.db_path.name))
+        all_messages = [self.message1, self.message2, self.message3, self.message4]
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
+        # add a new message, but only to the internal list
+        new_message = Message(Question("What?"))
+        all_messages_mem = all_messages + [new_message]
+        chat_db.msg_add([new_message])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages_mem)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages_mem)
+        # the nr. of messages on disk did not change -> expect old result
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
+        # test with MessageFilter
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all', mfilter=MessageFilter(tags_or={Tag('tag1')})),
+                                 [self.message1])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk', mfilter=MessageFilter(tags_or={Tag('tag2')})),
+                                 [self.message2])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache', mfilter=MessageFilter(tags_or={Tag('tag3')})),
+                                 [])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem', mfilter=MessageFilter(question_contains="What")),
+                                 [new_message])
+
+    def test_msg_move_and_gather(self) -> None:
+        chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
+                                  pathlib.Path(self.db_path.name))
+        all_messages = [self.message1, self.message2, self.message3, self.message4]
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
+        # move first message to the cache
+        chat_db.cache_move(self.message1)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [self.message1])
+        self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.cache_path.name))  # type: ignore [union-attr]
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), [self.message2, self.message3, self.message4])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages)
+        # now move first message back to the DB
+        chat_db.db_move(self.message1)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
+        self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.db_path.name))  # type: ignore [union-attr]
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
-- 
2.36.6


From 25fffb6fead97fe71a4ce84e40cc5c53444fadd3 Mon Sep 17 00:00:00 2001
From: juk0de <git@kadidlo.de>
Date: Sun, 17 Sep 2023 09:13:46 +0200
Subject: [PATCH 12/12] chat: db_read() and cache_read() now also support
 globbing and filtering

---
 chatmastermind/chat.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/chatmastermind/chat.py b/chatmastermind/chat.py
index 06895ac..17e5c38 100644
--- a/chatmastermind/chat.py
+++ b/chatmastermind/chat.py
@@ -107,7 +107,9 @@ def clear_dir(dir_path: Path,
     """
     file_iter = dir_path.glob(glob) if glob else dir_path.iterdir()
     for file_path in file_iter:
-        if file_path.is_file() and file_path.suffix in Message.file_suffixes:
+        if (file_path.is_file()
+           and file_path.name not in ignored_files  # noqa: W503
+           and file_path.suffix in Message.file_suffixes):  # noqa: W503
             file_path.unlink(missing_ok=True)
 
 
@@ -494,13 +496,13 @@ class ChatDB(Chat):
         else:
             return len(self.msg_find([message], loc='db')) > 0
 
-    def cache_read(self) -> None:
+    def cache_read(self, glob: Optional[str] = None, mfilter: Optional[MessageFilter] = None) -> None:
         """
         Read messages from the cache directory. New ones are added to the internal list,
         existing ones are replaced. A message is determined as 'existing' if a message
         with the same base filename (i. e. 'file_path.name') is already in the list.
         """
-        new_messages = read_dir(self.cache_path, self.glob, self.mfilter)
+        new_messages = read_dir(self.cache_path, glob, mfilter)
         # remove all messages from self.messages that are in the new list
         self.messages = [m for m in self.messages if not message_in(m, new_messages)]
         # copy the messages from the temporary list to self.messages and sort them
@@ -537,11 +539,11 @@ class ChatDB(Chat):
         self.messages += messages
         self.msg_sort()
 
-    def cache_clear(self) -> None:
+    def cache_clear(self, glob: Optional[str] = None) -> None:
         """
         Delete all message files from the cache dir and remove them from the internal list.
         """
-        clear_dir(self.cache_path, self.glob)
+        clear_dir(self.cache_path, glob)
         # only keep messages from DB dir (or those that have not yet been written)
         self.messages = [m for m in self.messages if not m.file_path or m.file_path.parent.samefile(self.db_path)]
 
@@ -561,7 +563,7 @@ class ChatDB(Chat):
         # (re)add it to the internal list
         self.msg_add([message])
 
-    def db_read(self) -> None:
+    def db_read(self, glob: Optional[str] = None, mfilter: Optional[MessageFilter] = None) -> None:
         """
         Read messages from the DB directory. New ones are added to the internal list,
         existing ones are replaced. A message is determined as 'existing' if a message
-- 
2.36.6