chat: added new functions: msg_unique_id(), msg_unique_content() and tests

README.md

@@ -46,32 +46,32 @@ cmm [global options] command [command options]
 The `question` command is used to ask, create, and process questions.
 
 ```bash
-cmm question [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-o OUTTAGS]... [-A AI_ID] [-M MODEL] [-n NUM] [-m MAX] [-T TEMP] (-a QUESTION | -c QUESTION | -r [MESSAGE ...] | -p [MESSAGE ...]) [-O] [-s FILE]... [-S FILE]...
+cmm question [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-o OUTTAGS]... [-A AI] [-M MODEL] [-n NUM] [-m MAX] [-T TEMP] (-a ASK | -c CREATE | -r REPEAT | -p PROCESS) [-O] [-s SOURCE]... [-S SOURCE]...
 ```
 
 * `-t, --or-tags OTAGS` : List of tags (one must match)
 * `-k, --and-tags ATAGS` : List of tags (all must match)
 * `-x, --exclude-tags XTAGS` : List of tags to exclude
 * `-o, --output-tags OUTTAGS` : List of output tags (default: use input tags)
-* `-A, --AI AI_ID`: AI ID to use
+* `-A, --AI AI` : AI ID to use
 * `-M, --model MODEL` : Model to use
 * `-n, --num-answers NUM` : Number of answers to request
 * `-m, --max-tokens MAX` : Max. number of tokens
 * `-T, --temperature TEMP` : Temperature value
-* `-a, --ask QUESTION`: Ask a question
+* `-a, --ask ASK` : Ask a question
-* `-c, --create QUESTION`: Create a question
+* `-c, --create CREATE` : Create a question
-* `-r, --repeat [MESSAGE ...]`: Repeat a question
+* `-r, --repeat REPEAT` : Repeat a question
-* `-p, --process [MESSAGE ...]`: Process existing questions
+* `-p, --process PROCESS` : Process existing questions
 * `-O, --overwrite` : Overwrite existing messages when repeating them
-* `-s, --source-text FILE`: Add content of a file to the query
+* `-s, --source-text SOURCE` : Add content of a file to the query
-* `-S, --source-code FILE`: Add source code file content to the chat history
+* `-S, --source-code SOURCE` : Add source code file content to the chat history
 
 #### Hist
 
 The `hist` command is used to print the chat history.
 
 ```bash
-cmm hist [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-w] [-W] [-S] [-A SUBSTRING] [-Q SUBSTRING]
+cmm hist [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-w] [-W] [-S] [-A ANSWER] [-Q QUESTION]
 ```
 
 * `-t, --or-tags OTAGS` : List of tags (one must match)
@@ -79,47 +79,46 @@ cmm hist [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-w] [-W] [-S] [-A SUBSTRING]
 * `-x, --exclude-tags XTAGS` : List of tags to exclude
 * `-w, --with-tags` : Print chat history with tags
 * `-W, --with-files` : Print chat history with filenames
-* `-S, --source-code-only`: Only print embedded source code
+* `-S, --source-code-only` : Print only source code
-* `-A, --answer SUBSTRING`: Search for answer substring
+* `-A, --answer ANSWER` : Search for answer substring
-* `-Q, --question SUBSTRING`: Search for question substring
+* `-Q, --question QUESTION` : Search for question substring
 
 #### Tags
 
 The `tags` command is used to manage tags.
 
 ```bash
-cmm tags (-l | -p PREFIX | -c SUBSTRING)
+cmm tags (-l | -p PREFIX | -c CONTENT)
 ```
 
 * `-l, --list` : List all tags and their frequency
 * `-p, --prefix PREFIX` : Filter tags by prefix
-* `-c, --contain SUBSTRING`: Filter tags by contained substring
+* `-c, --contain CONTENT` : Filter tags by contained substring
 
 #### Config
 
 The `config` command is used to manage the configuration.
 
 ```bash
-cmm config (-l | -m | -c FILE)
+cmm config (-l | -m | -c CREATE)
 ```
 
 * `-l, --list-models` : List all available models
 * `-m, --print-model` : Print the currently configured model
-* `-c, --create FILE`: Create config with default settings in the given file
+* `-c, --create CREATE` : Create config with default settings in the given file
 
 #### Print
 
 The `print` command is used to print message files.
 
 ```bash
-cmm print (-f FILE | -l) [-q | -a | -S]
+cmm print -f FILE [-q | -a | -S]
 ```
 
-* `-f, --file FILE`: Print given file
+* `-f, --file FILE` : File to print
-* `-l, --latest`: Print latest message
+* `-q, --question` : Print only question
-* `-q, --question`: Only print the question
+* `-a, --answer` : Print only answer
-* `-a, --answer`: Only print the answer
+* `-S, --only-source-code` : Print only source code
-* `-S, --only-source-code`: Only print embedded source code
 
 ### Examples
 
@@ -161,27 +160,18 @@ cmm print -f example.yaml
 
 ## Configuration
 
-The default configuration filename is `.config.yaml` (it is searched in the current working directory).
+The configuration file (`.config.yaml`) should contain the following fields:
-Use the command `cmm config --create <FILENAME>` to create a default configuration:
 
-```
+- `openai`:
-cache: .
+  - `api_key`: Your OpenAI API key.
-db: ./db/
+  - `model`: The name of the OpenAI model to use (e.g. "text-davinci-002").
-ais:
+  - `temperature`: The temperature value for the model.
-  myopenai:
+  - `max_tokens`: The maximum number of tokens for the model.
-    name: openai
+  - `top_p`: The top P value for the model.
-    model: gpt-3.5-turbo-16k
+  - `frequency_penalty`: The frequency penalty value.
-    api_key: 0123456789
+  - `presence_penalty`: The presence penalty value.
-    temperature: 1.0
+- `system`: The system message used to set the behavior of the AI.
-    max_tokens: 4000
+- `db`: The directory where the question-answer pairs are stored in YAML files.
-    top_p: 1.0
-    frequency_penalty: 0.0
-    presence_penalty: 0.0
-    system: You are an assistant
-```
-
-Each AI has its own section and the name of that section is called the 'AI ID' (in the example above it is `myopenai`).
-The AI ID can be any string, as long as it's unique within the `ais` section. The AI ID is used for all commands that support the `AI` parameter and it's also stored within each message file.
 
 ## Autocompletion
 
@@ -196,33 +186,33 @@ After adding this line, restart your shell or run `source <your-shell-config-fil
 ## Contributing
 
 ### Enable commit hooks
-```bash
+```
 pip install pre-commit
 pre-commit install
 ```
 ### Execute tests before opening a PR
-```bash
+```
 pytest
 ```
 ### Consider using `pyenv` / `pyenv-virtualenv`
 Short installation instructions:
 * install `pyenv`:
-```bash
+```
 cd ~
 git clone https://github.com/pyenv/pyenv .pyenv
 cd ~/.pyenv && src/configure && make -C src
 ```
-* make sure that `~/.pyenv/shims` and `~/.pyenv/bin` are the first entries in your `PATH`, e.g., by setting it in `~/.bashrc`
+* make sure that `~/.pyenv/shims` and `~/.pyenv/bin` are the first entries in your `PATH`, e. g. by setting it in `~/.bashrc`
 * add the following to your `~/.bashrc` (after setting `PATH`): `eval "$(pyenv init -)"`
-* create a new terminal or source the changes (e.g., `source ~/.bashrc`)
+* create a new terminal or source the changes (e. g. `source ~/.bashrc`)
 * install `virtualenv`
-```bash
+```
 git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
 ```
 * add the following to your `~/.bashrc` (after the commands above): `eval "$(pyenv virtualenv-init -)`
-* create a new terminal or source the changes (e.g., `source ~/.bashrc`)
+* create a new terminal or source the changes (e. g. `source ~/.bashrc`)
-* go back to the `ChatMasterMind` repo and create a virtual environment with the latest `Python`, e.g., `3.11.4`:
+* go back to the `ChatMasterMind` repo and create a virtual environment with the latest `Python`, e. g. `3.11.4`:
-```bash
+```
 cd <CMM_REPO_PATH>
 pyenv install 3.11.4
 pyenv virtualenv 3.11.4 py311
@@ -233,3 +223,5 @@ pyenv activate py311
 ## License
 
 This project is licensed under the terms of the WTFPL License.
+
+

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, Union
+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
@@ -16,7 +16,7 @@ ChatDBInst = TypeVar('ChatDBInst', bound='ChatDB')
 
 db_next_file = '.next'
 ignored_files = [db_next_file, default_config_file]
-msg_location = Literal['mem', 'disk', 'cache', 'db', 'all']
+valid_sources = Literal['mem', 'disk', 'cache', 'db', 'all']
 
 
 class ChatError(Exception):
@@ -107,9 +107,7 @@ 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()
+        if file_path.is_file() and file_path.suffix in Message.file_suffixes:
-           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)
 
 
@@ -121,25 +119,6 @@ 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.
@@ -215,9 +194,8 @@ 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), full paths or Message.msg_id(). Messages that can't be
+        (with or without suffix) or full paths. Messages that can't be found are ignored
-        found are ignored (i. e. the caller should check the result if they require all
+        (i. e. the caller should check the result if they require all messages).
-        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)]
@@ -225,7 +203,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), full paths or Message.msg_id().
+        (with or without suffix) or full paths.
         """
         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)]
@@ -297,7 +275,6 @@ 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],
@@ -375,11 +352,11 @@ class ChatDB(Chat):
             self.msg_write(messages)
 
     def msg_gather(self,
-                   loc: msg_location,
+                   source: valid_sources,
                    require_file_path: bool = False,
                    mfilter: Optional[MessageFilter] = None) -> list[Message]:
         """
-        Gather and return messages from the given locations:
+        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
@@ -388,63 +365,51 @@ class ChatDB(Chat):
 
         If 'require_file_path' is True, return only files with a valid file_path.
         """
-        loc_messages: list[Message] = []
+        source_messages: list[Message] = []
-        if loc in ['mem', 'all']:
+        if source in ['mem', 'all']:
             if require_file_path:
-                loc_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
+                source_messages += [m for m in self.messages if (m.file_path is not None and (mfilter is None or m.match(mfilter)))]
             else:
-                loc_messages += [m for m in self.messages if (mfilter is None or m.match(mfilter))]
+                source_messages += [m for m in self.messages if (mfilter is None or m.match(mfilter))]
-        if loc in ['cache', 'disk', 'all']:
+        if source in ['cache', 'disk', 'all']:
-            loc_messages += read_dir(self.cache_path, mfilter=mfilter)
+            source_messages += read_dir(self.cache_path, mfilter=mfilter)
-        if loc in ['db', 'disk', 'all']:
+        if source in ['db', 'disk', 'all']:
-            loc_messages += read_dir(self.db_path, mfilter=mfilter)
+            source_messages += read_dir(self.db_path, mfilter=mfilter)
         # remove_duplicates and sort the list
         unique_messages: list[Message] = []
-        for m in loc_messages:
+        for m in source_messages:
             if not message_in(m, unique_messages):
                 unique_messages.append(m)
-        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,
                  msg_names: list[str],
-                 loc: msg_location = 'mem',
+                 source: valid_sources = '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
+        (with or without suffix) or full paths. Messages that can't be found are ignored
-        found are ignored (i. e. the caller should check the result if they require all
+        (i. e. the caller should check the result if they require all messages).
-        messages).
+        Searches one of the following sources:
-        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')
         """
-        loc_messages = self.msg_gather(loc, require_file_path=True)
+        source_messages = self.msg_gather(source, require_file_path=True)
-        return [m for m in loc_messages
+        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], loc: msg_location = 'mem') -> None:
+    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), full paths or Message.msg_id(). Also deletes the
+        (with or without suffix) or full paths. Also deletes the files of all given
-        files of all given messages with a valid file_path.
+        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')
         """
-        if loc != 'mem':
         # delete the message files first
-            rm_messages = self.msg_find(msg_names, loc=loc)
+        rm_messages = self.msg_find(msg_names, source='all')
         for m in rm_messages:
             if (m.file_path):
                 m.file_path.unlink()
@@ -453,11 +418,11 @@ class ChatDB(Chat):
 
     def msg_latest(self,
                    mfilter: Optional[MessageFilter] = None,
-                   loc: msg_location = 'mem') -> Optional[Message]:
+                   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 loc is 'mem').
+        Only consider messages with a valid file_path (except if source is 'mem').
-        Searches one of the following locations:
+        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
@@ -465,44 +430,20 @@ class ChatDB(Chat):
         * 'all'  : all messages ('mem' + 'disk')
         """
         # only consider messages with a valid file_path so they can be sorted
-        loc_messages = self.msg_gather(loc, require_file_path=True)
+        source_messages = self.msg_gather(source, require_file_path=True)
-        loc_messages.sort(key=lambda m: m.msg_id(), reverse=True)
+        source_messages.sort(key=lambda m: m.msg_id(), reverse=True)
-        for m in loc_messages:
+        for m in source_messages:
             if mfilter is None or m.match(mfilter):
                 return m
         return None
 
-    def msg_in_cache(self, message: Union[Message, str]) -> bool:
+    def cache_read(self) -> None:
-        """
-        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, 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, glob, mfilter)
+        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
@@ -539,31 +480,15 @@ class ChatDB(Chat):
         self.messages += messages
         self.msg_sort()
 
-    def cache_clear(self, glob: Optional[str] = None) -> None:
+    def cache_clear(self) -> None:
         """
         Delete all message files from the cache dir and remove them from the internal list.
         """
-        clear_dir(self.cache_path, glob)
+        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 cache_move(self, message: Message) -> None:
+    def db_read(self) -> 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, 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
@@ -605,19 +530,3 @@ 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])

chatmastermind/commands/hist.py

@@ -15,7 +15,7 @@ def hist_cmd(args: argparse.Namespace, config: Config) -> None:
                             tags_not=args.exclude_tags,
                             question_contains=args.question,
                             answer_contains=args.answer)
-    chat = ChatDB.from_dir(Path(config.cache),
+    chat = ChatDB.from_dir(Path('.'),
                            Path(config.db),
                            mfilter=mfilter)
     chat.print(args.source_code_only,

chatmastermind/commands/print.py

@@ -3,13 +3,16 @@ import argparse
 from pathlib import Path
 from ..configuration import Config
 from ..message import Message, MessageError
-from ..chat import ChatDB
 
 
-def print_message(message: Message, args: argparse.Namespace) -> None:
+def print_cmd(args: argparse.Namespace, config: Config) -> None:
     """
-    Print given message according to give arguments.
+    Handler for the 'print' command.
     """
+    fname = Path(args.file)
+    try:
+        message = Message.from_file(fname)
+        if message:
             if args.question:
                 print(message.question)
             elif args.answer:
@@ -19,27 +22,6 @@ def print_message(message: Message, args: argparse.Namespace) -> None:
                     print(code)
             else:
                 print(message.to_str())
-
-
-def print_cmd(args: argparse.Namespace, config: Config) -> None:
-    """
-    Handler for the 'print' command.
-    """
-    # print given file
-    if args.file is not None:
-        fname = Path(args.file)
-        try:
-            message = Message.from_file(fname)
-            if message:
-                print_message(message, args)
     except MessageError:
         print(f"File is not a valid message: {args.file}")
         sys.exit(1)
-    # print latest message
-    elif args.latest:
-        chat = ChatDB.from_dir(Path(config.cache), Path(config.db))
-        latest = chat.msg_latest(loc='disk')
-        if not latest:
-            print("No message found!")
-            sys.exit(1)
-        print_message(latest, args)

chatmastermind/commands/question.py

@@ -52,7 +52,7 @@ def add_file_as_code(question_parts: list[str], file: str) -> None:
 
 def create_message(chat: ChatDB, args: argparse.Namespace) -> Message:
     """
-    Create a new message from the given arguments and write it
+    Creates a new message from the given arguments and writes it
     to the cache directory.
     """
     question_parts = []
@@ -71,31 +71,28 @@ def create_message(chat: ChatDB, args: argparse.Namespace) -> Message:
     full_question = '\n\n'.join(question_parts)
 
     message = Message(question=Question(full_question),
-                      tags=args.output_tags,
+                      tags=args.output_tags,  # FIXME
                       ai=args.AI,
                       model=args.model)
-    # only write the new message to the cache,
+    # only write the message (as a backup), don't add it
-    # don't add it to the internal list
+    # to the current chat history
     chat.cache_write([message])
     return message
 
 
 def make_request(ai: AI, chat: ChatDB, message: Message, args: argparse.Namespace) -> None:
     """
-    Make an AI request with the given AI, chat history, message and arguments.
+    Make an AI request with the give AI, chat history, message and CLI arguments.
-    Write the response(s) to the cache directory, without appending it to the
+    Print all answers.
-    given chat history. Then print the response(s).
     """
-    # print history and message question before making the request
     ai.print()
     chat.print(paged=False)
-    print(message.to_str())
+    print(message.to_str() + '\n')
     response: AIResponse = ai.request(message,
                                       chat,
                                       args.num_answers,
                                       args.output_tags)
-    # only write the response messages to the cache,
+    # write all answers to the cache, don't add them to the chat history
-    # don't add them to the internal list
     chat.cache_write(response.messages)
     for idx, msg in enumerate(response.messages):
         print(f"=== ANSWER {idx+1} ===")
@@ -112,7 +109,7 @@ def question_cmd(args: argparse.Namespace, config: Config) -> None:
     mfilter = MessageFilter(tags_or=args.or_tags if args.or_tags is not None else set(),
                             tags_and=args.and_tags if args.and_tags is not None else set(),
                             tags_not=args.exclude_tags if args.exclude_tags is not None else set())
-    chat = ChatDB.from_dir(cache_path=Path(config.cache),
+    chat = ChatDB.from_dir(cache_path=Path('.'),
                            db_path=Path(config.db),
                            mfilter=mfilter)
     # if it's a new question, create and store it immediately
@@ -129,7 +126,7 @@ def question_cmd(args: argparse.Namespace, config: Config) -> None:
         make_request(ai, chat, message, args)
     # === REPEAT ===
     elif args.repeat is not None:
-        lmessage = chat.msg_latest(loc='cache')
+        lmessage = chat.msg_latest(source='cache')
         if lmessage is None:
             print("No message found to repeat!")
             sys.exit(1)

chatmastermind/commands/tags.py

@@ -8,7 +8,7 @@ def tags_cmd(args: argparse.Namespace, config: Config) -> None:
     """
     Handler for the 'tags' command.
     """
-    chat = ChatDB.from_dir(cache_path=Path(config.cache),
+    chat = ChatDB.from_dir(cache_path=Path('.'),
                            db_path=Path(config.db))
     if args.list:
         tags_freq = chat.msg_tags_frequency(args.prefix, args.contain)

chatmastermind/configuration.py

@@ -116,7 +116,6 @@ class Config:
     """
     # all members have default values, so we can easily create
     # a default configuration
-    cache: str = '.'
     db: str = './db/'
     ais: dict[str, AIConfig] = field(default_factory=create_default_ai_configs)
 
@@ -133,7 +132,6 @@ class Config:
             ai_conf = ai_config_instance(conf['name'], conf)
             ais[ID] = ai_conf
         return cls(
-            cache=str(source['cache']) if 'cache' in source else '.',
             db=str(source['db']),
             ais=ais
         )

chatmastermind/main.py

@@ -44,13 +44,13 @@ def create_parser() -> argparse.ArgumentParser:
                                        help='List of tags to exclude', metavar='XTAGS')
     etag_arg.completer = tags_completer  # type: ignore
     otag_arg = tag_parser.add_argument('-o', '--output-tags', nargs='+',
-                                       help='List of output tags (default: use input tags)', metavar='OUTAGS')
+                                       help='List of output tags (default: use input tags)', metavar='OUTTAGS')
     otag_arg.completer = tags_completer  # type: ignore
 
     # a parent parser for all commands that support AI configuration
     ai_parser = argparse.ArgumentParser(add_help=False)
-    ai_parser.add_argument('-A', '--AI', help='AI ID to use', metavar='AI_ID')
+    ai_parser.add_argument('-A', '--AI', help='AI ID to use')
-    ai_parser.add_argument('-M', '--model', help='Model to use', metavar='MODEL')
+    ai_parser.add_argument('-M', '--model', help='Model to use')
     ai_parser.add_argument('-n', '--num-answers', help='Number of answers to request', type=int, default=1)
     ai_parser.add_argument('-m', '--max-tokens', help='Max. nr. of tokens', type=int)
     ai_parser.add_argument('-T', '--temperature', help='Temperature value', type=float)
@@ -61,15 +61,14 @@ def create_parser() -> argparse.ArgumentParser:
                                                aliases=['q'])
     question_cmd_parser.set_defaults(func=question_cmd)
     question_group = question_cmd_parser.add_mutually_exclusive_group(required=True)
-    question_group.add_argument('-a', '--ask', nargs='+', help='Ask a question', metavar='QUESTION')
+    question_group.add_argument('-a', '--ask', nargs='+', help='Ask a question')
-    question_group.add_argument('-c', '--create', nargs='+', help='Create a question', metavar='QUESTION')
+    question_group.add_argument('-c', '--create', nargs='+', help='Create a question')
-    question_group.add_argument('-r', '--repeat', nargs='*', help='Repeat a question', metavar='MESSAGE')
+    question_group.add_argument('-r', '--repeat', nargs='*', help='Repeat a question')
-    question_group.add_argument('-p', '--process', nargs='*', help='Process existing questions', metavar='MESSAGE')
+    question_group.add_argument('-p', '--process', nargs='*', help='Process existing questions')
     question_cmd_parser.add_argument('-O', '--overwrite', help='Overwrite existing messages when repeating them',
                                      action='store_true')
-    question_cmd_parser.add_argument('-s', '--source-text', nargs='+', help='Add content of a file to the query', metavar='FILE')
+    question_cmd_parser.add_argument('-s', '--source-text', nargs='+', help='Add content of a file to the query')
-    question_cmd_parser.add_argument('-S', '--source-code', nargs='+', help='Add source code file content to the chat history',
+    question_cmd_parser.add_argument('-S', '--source-code', nargs='+', help='Add source code file content to the chat history')
-                                     metavar='FILE')
 
     # 'hist' command parser
     hist_cmd_parser = cmdparser.add_parser('hist', parents=[tag_parser],
@@ -80,10 +79,10 @@ def create_parser() -> argparse.ArgumentParser:
                                  action='store_true')
     hist_cmd_parser.add_argument('-W', '--with-files', help="Print chat history with filenames.",
                                  action='store_true')
-    hist_cmd_parser.add_argument('-S', '--source-code-only', help='Only print embedded source code',
+    hist_cmd_parser.add_argument('-S', '--source-code-only', help='Print only source code',
                                  action='store_true')
-    hist_cmd_parser.add_argument('-A', '--answer', help='Search for answer substring', metavar='SUBSTRING')
+    hist_cmd_parser.add_argument('-A', '--answer', help='Search for answer substring')
-    hist_cmd_parser.add_argument('-Q', '--question', help='Search for question substring', metavar='SUBSTRING')
+    hist_cmd_parser.add_argument('-Q', '--question', help='Search for question substring')
 
     # 'tags' command parser
     tags_cmd_parser = cmdparser.add_parser('tags',
@@ -93,8 +92,8 @@ def create_parser() -> argparse.ArgumentParser:
     tags_group = tags_cmd_parser.add_mutually_exclusive_group(required=True)
     tags_group.add_argument('-l', '--list', help="List all tags and their frequency",
                             action='store_true')
-    tags_cmd_parser.add_argument('-p', '--prefix', help="Filter tags by prefix", metavar='PREFIX')
+    tags_cmd_parser.add_argument('-p', '--prefix', help="Filter tags by prefix")
-    tags_cmd_parser.add_argument('-c', '--contain', help="Filter tags by contained substring", metavar='SUBSTRING')
+    tags_cmd_parser.add_argument('-c', '--contain', help="Filter tags by contained substring")
 
     # 'config' command parser
     config_cmd_parser = cmdparser.add_parser('config',
@@ -107,20 +106,18 @@ def create_parser() -> argparse.ArgumentParser:
                               action='store_true')
     config_group.add_argument('-m', '--print-model', help="Print the currently configured model",
                               action='store_true')
-    config_group.add_argument('-c', '--create', help="Create config with default settings in the given file", metavar='FILE')
+    config_group.add_argument('-c', '--create', help="Create config with default settings in the given file")
 
     # 'print' command parser
     print_cmd_parser = cmdparser.add_parser('print',
                                             help="Print message files.",
                                             aliases=['p'])
     print_cmd_parser.set_defaults(func=print_cmd)
-    print_group = print_cmd_parser.add_mutually_exclusive_group(required=True)
+    print_cmd_parser.add_argument('-f', '--file', help='File to print', required=True)
-    print_group.add_argument('-f', '--file', help='Print given message file', metavar='FILE')
-    print_group.add_argument('-l', '--latest', help='Print latest message', action='store_true')
     print_cmd_modes = print_cmd_parser.add_mutually_exclusive_group()
-    print_cmd_modes.add_argument('-q', '--question', help='Only print the question', action='store_true')
+    print_cmd_modes.add_argument('-q', '--question', help='Print only question', action='store_true')
-    print_cmd_modes.add_argument('-a', '--answer', help='Only print the answer', action='store_true')
+    print_cmd_modes.add_argument('-a', '--answer', help='Print only answer', action='store_true')
-    print_cmd_modes.add_argument('-S', '--only-source-code', help='Only print embedded source code', action='store_true')
+    print_cmd_modes.add_argument('-S', '--only-source-code', help='Print only source code', action='store_true')
 
     argcomplete.autocomplete(parser)
     return parser

chatmastermind/message.py

@@ -222,36 +222,12 @@ class Message():
     ai_yaml_key: ClassVar[str] = 'ai'
     model_yaml_key: ClassVar[str] = 'model'
 
-    def __post_init__(self) -> None:
-        # convert some types that are often set wrong
-        if self.tags is not None and not isinstance(self.tags, set):
-            self.tags = set(self.tags)
-        if self.file_path is not None and not isinstance(self.file_path, pathlib.Path):
-            self.file_path = pathlib.Path(self.file_path)
-
     def __hash__(self) -> int:
         """
         The hash value is computed based on immutable members.
         """
         return hash((self.question, self.answer))
 
-    def equals(self, other: MessageInst, tags: bool = True, ai: bool = True,
-               model: bool = True, file_path: bool = True, verbose: bool = False) -> bool:
-        """
-        Compare this message with another one, including the metadata.
-        Return True if everything is identical, False otherwise.
-        """
-        equal: bool = ((not tags or (self.tags == other.tags))
-                       and (not ai or (self.ai == other.ai))  # noqa: W503
-                       and (not model or (self.model == other.model))  # noqa: W503
-                       and (not file_path or (self.file_path == other.file_path))  # noqa: W503
-                       and (self == other))  # noqa: W503
-        if not equal and verbose:
-            print("Messages not equal:")
-            print(self)
-            print(other)
-        return equal
-
     @classmethod
     def from_dict(cls: Type[MessageInst], data: dict[str, Any]) -> MessageInst:
         """
@@ -417,9 +393,9 @@ class Message():
             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")
+            return cls.from_dict(data)
 
     def to_str(self, with_tags: bool = False, with_file: bool = False, source_code_only: bool = False) -> str:
         """
@@ -442,6 +418,9 @@ class Message():
             output.append(self.answer)
         return '\n'.join(output)
 
+    def __str__(self) -> str:
+        return self.to_str(True, True, False)
+
     def to_file(self, file_path: Optional[pathlib.Path]=None) -> None:  # noqa: 11
         """
         Write a Message to the given file. Type is determined based on the suffix.
@@ -567,11 +546,10 @@ 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 without suffix. The ID is also used for sorting
+        Currently this is the file name. The ID is also used for sorting messages.
-        messages.
         """
         if self.file_path:
-            return self.file_path.stem
+            return self.file_path.name
         else:
             raise MessageError("Can't create file ID without a file path")
 

tests/test_chat.py

@@ -2,7 +2,6 @@ import unittest
 import pathlib
 import tempfile
 import time
-import yaml
 from io import StringIO
 from unittest.mock import patch
 from chatmastermind.tags import TagLine
@@ -10,18 +9,7 @@ from chatmastermind.message import Message, Question, Answer, Tag, MessageFilter
 from chatmastermind.chat import Chat, ChatDB, ChatError
 
 
-class TestChatBase(unittest.TestCase):
+class TestChat(unittest.TestCase):
-    def assert_messages_equal(self, msg1: list[Message], msg2: list[Message]) -> None:
-        """
-        Compare messages using more than just Question and Answer.
-        """
-        self.assertEqual(len(msg1), len(msg2))
-        for m1, m2 in zip(msg1, msg2):
-            # exclude the file_path, compare only Q, A and metadata
-            self.assertTrue(m1.equals(m2, file_path=False, verbose=True))
-
-
-class TestChat(TestChatBase):
     def setUp(self) -> None:
         self.chat = Chat([])
         self.message1 = Message(Question('Question 1'),
@@ -37,24 +25,24 @@ class TestChat(TestChatBase):
     def test_unique_id(self) -> None:
         # test with two identical messages
         self.chat.msg_add([self.message1, self.message1])
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message1])
         self.chat.msg_unique_id()
-        self.assert_messages_equal(self.chat.messages, [self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1])
         # test with two different messages
         self.chat.msg_add([self.message2])
         self.chat.msg_unique_id()
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message2])
+        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.assert_messages_equal(self.chat.messages, [self.message1, self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message1])
         self.chat.msg_unique_content()
-        self.assert_messages_equal(self.chat.messages, [self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1])
         # test with two different messages
         self.chat.msg_add([self.message2])
         self.chat.msg_unique_content()
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message2])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message2])
 
     def test_filter(self) -> None:
         self.chat.msg_add([self.message1, self.message2])
@@ -161,7 +149,7 @@ Answer 2
         self.assertEqual(mock_stdout.getvalue(), expected_output)
 
 
-class TestChatDB(TestChatBase):
+class TestChatDB(unittest.TestCase):
     def setUp(self) -> None:
         self.db_path = tempfile.TemporaryDirectory()
         self.cache_path = tempfile.TemporaryDirectory()
@@ -196,10 +184,6 @@ class TestChatDB(TestChatBase):
         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]:
@@ -214,17 +198,6 @@ class TestChatDB(TestChatBase):
         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))
@@ -300,25 +273,6 @@ class TestChatDB(TestChatBase):
         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),
@@ -561,92 +515,39 @@ class TestChatDB(TestChatBase):
         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)], loc='mem'), [self.message1])
+        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()], loc='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find(['0001.txt'], source='mem'), [self.message1])
-        self.assertEqual(chat_db.msg_find(['0001.txt'], loc='mem'), [self.message1])
+        self.assertEqual(chat_db.msg_find(['0001'], source='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)], loc='db'), [self.message2])
+        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()], loc='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find(['0002.yaml'], source='db'), [self.message2])
-        self.assertEqual(chat_db.msg_find(['0002.yaml'], loc='db'), [self.message2])
+        self.assertEqual(chat_db.msg_find(['0002'], source='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)], loc='cache'), [])
+        self.assertEqual(chat_db.msg_find([str(self.message3.file_path)], source='cache'), [])
-        self.assertEqual(chat_db.msg_find([self.message3.msg_id()], loc='cache'), [])
+        self.assertEqual(chat_db.msg_find(['0003.txt'], source='cache'), [])
-        self.assertEqual(chat_db.msg_find(['0003.txt'], loc='cache'), [])
+        self.assertEqual(chat_db.msg_find(['0003'], source='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', str(self.message3.file_path)]
-        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, loc='all')
+        result = chat_db.msg_find(search_names, source='all')
-        self.assert_messages_equal(result, expected_result)
+        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(loc='mem'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='mem'), self.message4)
-        self.assertEqual(chat_db.msg_latest(loc='db'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='db'), self.message4)
-        self.assertEqual(chat_db.msg_latest(loc='disk'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='disk'), self.message4)
-        self.assertEqual(chat_db.msg_latest(loc='all'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='all'), self.message4)
         # the cache is currently empty:
-        self.assertIsNone(chat_db.msg_latest(loc='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.cache_add([new_message])
-        self.assertEqual(chat_db.msg_latest(loc='cache'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='cache'), new_message)
-        self.assertEqual(chat_db.msg_latest(loc='mem'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='mem'), new_message)
-        self.assertEqual(chat_db.msg_latest(loc='disk'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='disk'), new_message)
-        self.assertEqual(chat_db.msg_latest(loc='all'), new_message)
+        self.assertEqual(chat_db.msg_latest(source='all'), new_message)
         # the DB does not contain the new message
-        self.assertEqual(chat_db.msg_latest(loc='db'), self.message4)
+        self.assertEqual(chat_db.msg_latest(source='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.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages)
-        self.assert_messages_equal(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.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages_mem)
-        self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages_mem)
-        # the nr. of messages on disk did not change -> expect old result
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
-        # test with MessageFilter
-        self.assert_messages_equal(chat_db.msg_gather(loc='all', mfilter=MessageFilter(tags_or={Tag('tag1')})),
-                                   [self.message1])
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk', mfilter=MessageFilter(tags_or={Tag('tag2')})),
-                                   [self.message2])
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache', mfilter=MessageFilter(tags_or={Tag('tag3')})),
-                                   [])
-        self.assert_messages_equal(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.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
-        # move first message to the cache
-        chat_db.cache_move(self.message1)
-        self.assert_messages_equal(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.assert_messages_equal(chat_db.msg_gather(loc='db'), [self.message2, self.message3, self.message4])
-        self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages)
-        # now move first message back to the DB
-        chat_db.db_move(self.message1)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
-        self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.db_path.name))  # type: ignore [union-attr]
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)

tests/test_configuration.py

@@ -57,7 +57,6 @@ class TestConfig(unittest.TestCase):
 
     def test_from_dict_should_create_config_from_dict(self) -> None:
         source_dict = {
-            'cache': '.',
             'db': './test_db/',
             'ais': {
                 'myopenai': {
@@ -74,7 +73,6 @@ class TestConfig(unittest.TestCase):
             }
         }
         config = Config.from_dict(source_dict)
-        self.assertEqual(config.cache, '.')
         self.assertEqual(config.db, './test_db/')
         self.assertEqual(len(config.ais), 1)
         self.assertEqual(config.ais['myopenai'].name, 'openai')
@@ -91,7 +89,6 @@ class TestConfig(unittest.TestCase):
 
     def test_from_file_should_load_config_from_file(self) -> None:
         source_dict = {
-            'cache': './test_cache/',
             'db': './test_db/',
             'ais': {
                 'default': {
@@ -111,7 +108,6 @@ class TestConfig(unittest.TestCase):
             yaml.dump(source_dict, f)
         config = Config.from_file(self.test_file.name)
         self.assertIsInstance(config, Config)
-        self.assertEqual(config.cache, './test_cache/')
         self.assertEqual(config.db, './test_db/')
         self.assertEqual(len(config.ais), 1)
         self.assertIsInstance(config.ais['default'], AIConfig)
@@ -119,7 +115,6 @@ class TestConfig(unittest.TestCase):
 
     def test_to_file_should_save_config_to_file(self) -> None:
         config = Config(
-            cache='./test_cache/',
             db='./test_db/',
             ais={
                 'myopenai': OpenAIConfig(
@@ -138,14 +133,12 @@ class TestConfig(unittest.TestCase):
         config.to_file(Path(self.test_file.name))
         with open(self.test_file.name, 'r') as f:
             saved_config = yaml.load(f, Loader=yaml.FullLoader)
-        self.assertEqual(saved_config['cache'], './test_cache/')
         self.assertEqual(saved_config['db'], './test_db/')
         self.assertEqual(len(saved_config['ais']), 1)
         self.assertEqual(saved_config['ais']['myopenai']['system'], 'Custom system')
 
     def test_from_file_error_unknown_ai(self) -> None:
         source_dict = {
-            'cache': './test_cache/',
             'db': './test_db/',
             'ais': {
                 'default': {

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.stem)
+        self.assertEqual(self.message.msg_id(), self.file_path.name)
 
     def test_msg_id_txt_exception(self) -> None:
         with self.assertRaises(MessageError):

tests/test_question_cmd.py

@@ -3,39 +3,23 @@ import unittest
 import argparse
 import tempfile
 from pathlib import Path
-from unittest import mock
+from unittest.mock import MagicMock
-from unittest.mock import MagicMock, call, ANY
+from chatmastermind.commands.question import create_message
-from typing import Optional
-from chatmastermind.configuration import Config
-from chatmastermind.commands.question import create_message, question_cmd
-from chatmastermind.tags import Tag
 from chatmastermind.message import Message, Question, Answer
-from chatmastermind.chat import Chat, ChatDB
+from chatmastermind.chat import ChatDB
-from chatmastermind.ai import AI, AIResponse, Tokens, AIError
 
 
-class TestQuestionCmdBase(unittest.TestCase):
+class TestMessageCreate(unittest.TestCase):
-    def assert_messages_equal(self, msg1: list[Message], msg2: list[Message]) -> None:
-        """
-        Compare messages using more than just Question and Answer.
-        """
-        self.assertEqual(len(msg1), len(msg2))
-        for m1, m2 in zip(msg1, msg2):
-            # exclude the file_path, compare only Q, A and metadata
-            self.assertTrue(m1.equals(m2, file_path=False, verbose=True))
-
-
-class TestMessageCreate(TestQuestionCmdBase):
     """
     Test if messages created by the 'question' command have
     the correct format.
     """
     def setUp(self) -> None:
         # create ChatDB structure
-        self.db_dir = tempfile.TemporaryDirectory()
+        self.db_path = tempfile.TemporaryDirectory()
-        self.cache_dir = tempfile.TemporaryDirectory()
+        self.cache_path = tempfile.TemporaryDirectory()
-        self.chat = ChatDB.from_dir(cache_path=Path(self.cache_dir.name),
+        self.chat = ChatDB.from_dir(cache_path=Path(self.cache_path.name),
-                                    db_path=Path(self.db_dir.name))
+                                    db_path=Path(self.db_path.name))
         # create some messages
         self.message_text = Message(Question("What is this?"),
                                     Answer("It is pure text"))
@@ -90,7 +74,6 @@ Aaaand again some text."""
         os.remove(self.source_file1.name)
         os.remove(self.source_file2.name)
         os.remove(self.source_file3.name)
-        os.remove(self.source_file4.name)
 
     def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[Path]:
         # exclude '.next'
@@ -98,10 +81,10 @@ Aaaand again some text."""
 
     def test_message_file_created(self) -> None:
         self.args.ask = ["What is this?"]
-        cache_dir_files = self.message_list(self.cache_dir)
+        cache_dir_files = self.message_list(self.cache_path)
         self.assertEqual(len(cache_dir_files), 0)
         create_message(self.chat, self.args)
-        cache_dir_files = self.message_list(self.cache_dir)
+        cache_dir_files = self.message_list(self.cache_path)
         self.assertEqual(len(cache_dir_files), 1)
         message = Message.from_file(cache_dir_files[0])
         self.assertIsInstance(message, Message)
@@ -210,304 +193,3 @@ This is embedded source code.
 It is embedded code
 ```
 """))
-
-
-class TestQuestionCmd(TestQuestionCmdBase):
-
-    def setUp(self) -> None:
-        # create DB and cache
-        self.db_dir = tempfile.TemporaryDirectory()
-        self.cache_dir = tempfile.TemporaryDirectory()
-        # create configuration
-        self.config = Config()
-        self.config.cache = self.cache_dir.name
-        self.config.db = self.db_dir.name
-        # create a mock argparse.Namespace
-        self.args = argparse.Namespace(
-            ask=['What is the meaning of life?'],
-            num_answers=1,
-            output_tags=['science'],
-            AI='openai',
-            model='gpt-3.5-turbo',
-            or_tags=None,
-            and_tags=None,
-            exclude_tags=None,
-            source_text=None,
-            source_code=None,
-            create=None,
-            repeat=None,
-            process=None,
-            overwrite=None
-        )
-        # create a mock AI instance
-        self.ai = MagicMock(spec=AI)
-        self.ai.request.side_effect = self.mock_request
-
-    def input_message(self, args: argparse.Namespace) -> Message:
-        """
-        Create the expected input message for a question using the
-        given arguments.
-        """
-        # NOTE: we only use the first question from the "ask" list
-        # -> message creation using "question.create_message()" is
-        #    tested above
-        # the answer is always empty for the input message
-        return Message(Question(args.ask[0]),
-                       tags=args.output_tags,
-                       ai=args.AI,
-                       model=args.model)
-
-    def mock_request(self,
-                     question: Message,
-                     chat: Chat,
-                     num_answers: int = 1,
-                     otags: Optional[set[Tag]] = None) -> AIResponse:
-        """
-        Mock the 'ai.request()' function
-        """
-        question.answer = Answer("Answer 0")
-        question.tags = set(otags) if otags else None
-        question.ai = 'FakeAI'
-        question.model = 'FakeModel'
-        answers: list[Message] = [question]
-        for n in range(1, num_answers):
-            answers.append(Message(question=question.question,
-                                   answer=Answer(f"Answer {n}"),
-                                   tags=otags,
-                                   ai='FakeAI',
-                                   model='FakeModel'))
-        return AIResponse(answers, Tokens(10, 10, 20))
-
-    def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[Path]:
-        # exclude '.next'
-        return sorted([f for f in Path(tmp_dir.name).glob('*.[ty]*')])
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_ask_single_answer(self, mock_create_ai: MagicMock) -> None:
-        """
-        Test single answer with no errors.
-        """
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-
-        # execute the command
-        question_cmd(self.args, self.config)
-
-        # check for correct request call
-        self.ai.request.assert_called_once_with(expected_question,
-                                                ANY,
-                                                self.args.num_answers,
-                                                self.args.output_tags)
-        # check for the expected message files
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-    @mock.patch('chatmastermind.commands.question.ChatDB.from_dir')
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_ask_single_answer_mocked(self, mock_create_ai: MagicMock, mock_from_dir: MagicMock) -> None:
-        """
-        Test single answer with no errors (mocked ChatDB version).
-        """
-        chat = MagicMock(spec=ChatDB)
-        mock_from_dir.return_value = chat
-
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-
-        # execute the command
-        question_cmd(self.args, self.config)
-
-        # check for correct request call
-        self.ai.request.assert_called_once_with(expected_question,
-                                                chat,
-                                                self.args.num_answers,
-                                                self.args.output_tags)
-
-        # check for the correct ChatDB calls:
-        # - initial question has been written (prior to the actual request)
-        # - responses have been written (after the request)
-        chat.cache_write.assert_has_calls([call([expected_question]),
-                                           call(expected_responses)],
-                                          any_order=False)
-
-        # check that the messages have not been added to the internal message list
-        chat.cache_add.assert_not_called()
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_ask_with_error(self, mock_create_ai: MagicMock) -> None:
-        """
-        Provoke an error during the AI request and verify that the question
-        has been correctly stored in the cache.
-        """
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        self.ai.request.side_effect = AIError
-
-        # execute the command
-        with self.assertRaises(AIError):
-            question_cmd(self.args, self.config)
-
-        # check for correct request call
-        self.ai.request.assert_called_once_with(expected_question,
-                                                ANY,
-                                                self.args.num_answers,
-                                                self.args.output_tags)
-        # check for the expected message files
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, [expected_question])
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question.
-        """
-        # 1. ask a question
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-        # 2. repeat the last question (without overwriting)
-        # -> expect two identical messages (except for the file_path)
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = False
-        expected_responses += expected_responses
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 2)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question_overwrite(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question and overwrite the old one.
-        """
-        # 1. ask a question
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        assert cached_msg[0].file_path
-        cached_msg_file_id = cached_msg[0].file_path.stem
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-        # 2. repeat the last question (WITH overwriting)
-        # -> expect a single message afterwards
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = True
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-        # also check that the file ID has not been changed
-        assert cached_msg[0].file_path
-        self.assertEqual(cached_msg_file_id, cached_msg[0].file_path.stem)
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question_after_error(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question after an error.
-        """
-        # 1. ask a question and provoke an error
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        self.ai.request.side_effect = AIError
-        with self.assertRaises(AIError):
-            question_cmd(self.args, self.config)
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        assert cached_msg[0].file_path
-        cached_msg_file_id = cached_msg[0].file_path.stem
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, [expected_question])
-
-        # 2. repeat the last question (without overwriting)
-        # -> expect a single message because if the original has
-        #    no answer, it should be overwritten by default
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = False
-        self.ai.request.side_effect = self.mock_request
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-        # also check that the file ID has not been changed
-        assert cached_msg[0].file_path
-        self.assertEqual(cached_msg_file_id, cached_msg[0].file_path.stem)
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question_new_args(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question with new arguments.
-        """
-        # 1. ask a question
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-        # 2. repeat the last question with new arguments (without overwriting)
-        # -> expect two messages with identical question and answer, but different metadata
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = False
-        self.args.output_tags = ['newtag']
-        self.args.AI = 'newai'
-        self.args.model = 'newmodel'
-        new_expected_question = Message(question=Question(expected_question.question),
-                                        tags=set(self.args.output_tags),
-                                        ai=self.args.AI,
-                                        model=self.args.model)
-        expected_responses += self.mock_request(new_expected_question,
-                                                Chat([]),
-                                                self.args.num_answers,
-                                                set(self.args.output_tags)).messages
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 2)
-        self.assert_messages_equal(cached_msg, expected_responses)