added tests for 'chat.py'

README.md

@@ -37,95 +37,63 @@ cmm [global options] command [command options]
 
 ### Global Options
 
-- `-C`, `--config`: Config file name (defaults to `.config.yaml`).
+- `-c`, `--config`: Config file name (defaults to `.config.yaml`).
+
+### Commands
+
+- `ask`: Ask a question.
+- `hist`: Print chat history.
+- `tag`: Manage tags.
+- `config`: Manage configuration.
+- `print`: Print files.
 
 ### Command Options
 
-#### Question
+#### `ask` Command Options
 
-The `question` command is used to ask, create, and process questions.
+- `-q`, `--question`: Question to ask (required).
+- `-m`, `--max-tokens`: Max tokens to use.
+- `-T`, `--temperature`: Temperature to use.
+- `-M`, `--model`: Model to use.
+- `-n`, `--number`: Number of answers to produce (default is 3).
+- `-s`, `--source`: Add content of a file to the query.
+- `-S`, `--only-source-code`: Add pure source code to the chat history.
+- `-t`, `--tags`: List of tag names.
+- `-e`, `--extags`: List of tag names to exclude.
+- `-o`, `--output-tags`: List of output tag names (default is the input tags).
+- `-a`, `--match-all-tags`: All given tags must match when selecting chat history entries.
 
-```bash
-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]...
-```
+#### `hist` Command Options
 
-* `-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` : 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 ASK` : Ask a question
-* `-c, --create CREATE` : Create a question
-* `-r, --repeat REPEAT` : Repeat a question
-* `-p, --process PROCESS` : Process existing questions
-* `-O, --overwrite` : Overwrite existing messages when repeating them
-* `-s, --source-text SOURCE` : Add content of a file to the query
-* `-S, --source-code SOURCE` : Add source code file content to the chat history
+- `-d`, `--dump`: Print chat history as Python structure.
+- `-w`, `--with-tags`: Print chat history with tags.
+- `-W`, `--with-files`: Print chat history with filenames.
+- `-S`, `--only-source-code`: Print only source code.
+- `-t`, `--tags`: List of tag names.
+- `-e`, `--extags`: List of tag names to exclude.
+- `-a`, `--match-all-tags`: All given tags must match when selecting chat history entries.
 
-#### Hist
+#### `tag` Command Options
 
-The `hist` command is used to print the chat history.
+- `-l`, `--list`: List all tags and their frequency.
 
-```bash
-cmm hist [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-w] [-W] [-S] [-A ANSWER] [-Q QUESTION]
-```
+#### `config` Command Options
 
-* `-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
-* `-w, --with-tags` : Print chat history with tags
-* `-W, --with-files` : Print chat history with filenames
-* `-S, --source-code-only` : Print only source code
-* `-A, --answer ANSWER` : Search for answer substring
-* `-Q, --question QUESTION` : Search for question substring
+- `-l`, `--list-models`: List all available models.
+- `-m`, `--print-model`: Print the currently configured model.
+- `-M`, `--model`: Set model in the config file.
 
-#### Tags
+#### `print` Command Options
 
-The `tags` command is used to manage tags.
-
-```bash
-cmm tags (-l | -p PREFIX | -c CONTENT)
-```
-
-* `-l, --list` : List all tags and their frequency
-* `-p, --prefix PREFIX` : Filter tags by prefix
-* `-c, --contain CONTENT` : Filter tags by contained substring
-
-#### Config
-
-The `config` command is used to manage the configuration.
-
-```bash
-cmm config (-l | -m | -c CREATE)
-```
-
-* `-l, --list-models` : List all available models
-* `-m, --print-model` : Print the currently configured model
-* `-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 [-q | -a | -S]
-```
-
-* `-f, --file FILE` : File to print
-* `-q, --question` : Print only question
-* `-a, --answer` : Print only answer
-* `-S, --only-source-code` : Print only source code
+- `-f`, `--file`: File to print (required).
+- `-S`, `--only-source-code`: Print only source code.
 
 ### Examples
 
 1. Ask a question:
 
 ```bash
-cmm question -a "What is the meaning of life?" -t philosophy -x religion
+cmm ask -q "What is the meaning of life?" -t philosophy -e religion
 ```
 
 2. Display the chat history:
@@ -137,19 +105,19 @@ cmm hist
 3. Filter chat history by tags:
 
 ```bash
-cmm hist --or-tags tag1 tag2
+cmm hist -t tag1 tag2
 ```
 
 4. Exclude chat history by tags:
 
 ```bash
-cmm hist --exclude-tags tag3 tag4
+cmm hist -e tag3 tag4
 ```
 
 5. List all tags and their frequency:
 
 ```bash
-cmm tags -l
+cmm tag -l
 ```
 
 6. Print the contents of a file:

chatmastermind/ai.py

@@ -1,80 +0,0 @@
-from dataclasses import dataclass
-from typing import Protocol, Optional, Union
-from .configuration import AIConfig
-from .tags import Tag
-from .message import Message
-from .chat import Chat
-
-
-class AIError(Exception):
-    pass
-
-
-@dataclass
-class Tokens:
-    prompt: int = 0
-    completion: int = 0
-    total: int = 0
-
-
-@dataclass
-class AIResponse:
-    """
-    The response to an AI request. Consists of one or more messages
-    (each containing the question and a single answer) and the nr.
-    of used tokens.
-    """
-    messages: list[Message]
-    tokens: Optional[Tokens] = None
-
-
-class AI(Protocol):
-    """
-    The base class for AI clients.
-    """
-
-    ID: str
-    name: str
-    config: AIConfig
-
-    def request(self,
-                question: Message,
-                chat: Chat,
-                num_answers: int = 1,
-                otags: Optional[set[Tag]] = None) -> AIResponse:
-        """
-        Make an AI request. Parameters:
-        * question: the question to ask
-        * chat: the chat history to be added as context
-        * num_answers: nr. of requested answers (corresponds
-          to the nr. of messages in the 'AIResponse')
-        * otags: the output tags, i. e. the tags that all
-          returned messages should contain
-        """
-        raise NotImplementedError
-
-    def models(self) -> list[str]:
-        """
-        Return all models supported by this AI.
-        """
-        raise NotImplementedError
-
-    def print_models(self) -> None:
-        """
-        Print all models supported by this AI.
-        """
-        raise NotImplementedError
-
-    def tokens(self, data: Union[Message, Chat]) -> int:
-        """
-        Computes the nr. of AI language tokens for the given message
-        or chat. Note that the computation may not be 100% accurate
-        and is not implemented for all AIs.
-        """
-        raise NotImplementedError
-
-    def print(self) -> None:
-        """
-        Print some info about the current AI, like system message.
-        """
-        pass

chatmastermind/ai_factory.py

@@ -1,43 +0,0 @@
-"""
-Creates different AI instances, based on the given configuration.
-"""
-
-import argparse
-from typing import cast
-from .configuration import Config, AIConfig, OpenAIConfig
-from .ai import AI, AIError
-from .ais.openai import OpenAI
-
-
-def create_ai(args: argparse.Namespace, config: Config) -> AI:  # noqa: 11
-    """
-    Creates an AI subclass instance from the given arguments
-    and configuration file. If AI has not been set in the
-    arguments, it searches for the ID 'default'. If that
-    is not found, it uses the first AI in the list.
-    """
-    ai_conf: AIConfig
-    if hasattr(args, 'AI') and args.AI:
-        try:
-            ai_conf = config.ais[args.AI]
-        except KeyError:
-            raise AIError(f"AI ID '{args.AI}' does not exist in this configuration")
-    elif 'default' in config.ais:
-        ai_conf = config.ais['default']
-    else:
-        try:
-            ai_conf = next(iter(config.ais.values()))
-        except StopIteration:
-            raise AIError("No AI found in this configuration")
-
-    if ai_conf.name == 'openai':
-        ai = OpenAI(cast(OpenAIConfig, ai_conf))
-        if hasattr(args, 'model') and args.model:
-            ai.config.model = args.model
-        if hasattr(args, 'max_tokens') and args.max_tokens:
-            ai.config.max_tokens = args.max_tokens
-        if hasattr(args, 'temperature') and args.temperature:
-            ai.config.temperature = args.temperature
-        return ai
-    else:
-        raise AIError(f"AI '{args.AI}' is not supported")

chatmastermind/ais/openai.py

@@ -1,111 +0,0 @@
-"""
-Implements the OpenAI client classes and functions.
-"""
-import openai
-from typing import Optional, Union
-from ..tags import Tag
-from ..message import Message, Answer
-from ..chat import Chat
-from ..ai import AI, AIResponse, Tokens
-from ..configuration import OpenAIConfig
-
-ChatType = list[dict[str, str]]
-
-
-class OpenAI(AI):
-    """
-    The OpenAI AI client.
-    """
-
-    def __init__(self, config: OpenAIConfig) -> None:
-        self.ID = config.ID
-        self.name = config.name
-        self.config = config
-        openai.api_key = config.api_key
-
-    def request(self,
-                question: Message,
-                chat: Chat,
-                num_answers: int = 1,
-                otags: Optional[set[Tag]] = None) -> AIResponse:
-        """
-        Make an AI request, asking the given question with the given
-        chat history. The nr. of requested answers corresponds to the
-        nr. of messages in the 'AIResponse'.
-        """
-        oai_chat = self.openai_chat(chat, self.config.system, question)
-        response = openai.ChatCompletion.create(
-            model=self.config.model,
-            messages=oai_chat,
-            temperature=self.config.temperature,
-            max_tokens=self.config.max_tokens,
-            top_p=self.config.top_p,
-            n=num_answers,
-            frequency_penalty=self.config.frequency_penalty,
-            presence_penalty=self.config.presence_penalty)
-        question.answer = Answer(response['choices'][0]['message']['content'])
-        question.tags = otags
-        question.ai = self.ID
-        question.model = self.config.model
-        answers: list[Message] = [question]
-        for choice in response['choices'][1:]:  # type: ignore
-            answers.append(Message(question=question.question,
-                                   answer=Answer(choice['message']['content']),
-                                   tags=otags,
-                                   ai=self.ID,
-                                   model=self.config.model))
-        return AIResponse(answers, Tokens(response['usage']['prompt_tokens'],
-                                          response['usage']['completion_tokens'],
-                                          response['usage']['total_tokens']))
-
-    def models(self) -> list[str]:
-        """
-        Return all models supported by this AI.
-        """
-        ret = []
-        for engine in sorted(openai.Engine.list()['data'], key=lambda x: x['id']):
-            if engine['ready']:
-                ret.append(engine['id'])
-        ret.sort()
-        return ret
-
-    def print_models(self) -> None:
-        """
-        Print all models supported by the current AI.
-        """
-        not_ready = []
-        for engine in sorted(openai.Engine.list()['data'], key=lambda x: x['id']):
-            if engine['ready']:
-                print(engine['id'])
-            else:
-                not_ready.append(engine['id'])
-        if len(not_ready) > 0:
-            print('\nNot ready: ' + ', '.join(not_ready))
-
-    def openai_chat(self, chat: Chat, system: str,
-                    question: Optional[Message] = None) -> ChatType:
-        """
-        Create a chat history with system message in OpenAI format.
-        Optionally append a new question.
-        """
-        oai_chat: ChatType = []
-
-        def append(role: str, content: str) -> None:
-            oai_chat.append({'role': role, 'content': content.replace("''", "'")})
-
-        append('system', system)
-        for message in chat.messages:
-            if message.answer:
-                append('user', message.question)
-                append('assistant', message.answer)
-        if question:
-            append('user', question.question)
-        return oai_chat
-
-    def tokens(self, data: Union[Message, Chat]) -> int:
-        raise NotImplementedError
-
-    def print(self) -> None:
-        print(f"MODEL: {self.config.model}")
-        print("=== SYSTEM ===")
-        print(self.config.system)

chatmastermind/api_client.py

@@ -0,0 +1,45 @@
+import openai
+
+from .utils import ChatType
+from .configuration import Config
+
+
+def openai_api_key(api_key: str) -> None:
+    openai.api_key = api_key
+
+
+def print_models() -> None:
+    """
+    Print all models supported by the current AI.
+    """
+    not_ready = []
+    for engine in sorted(openai.Engine.list()['data'], key=lambda x: x['id']):
+        if engine['ready']:
+            print(engine['id'])
+        else:
+            not_ready.append(engine['id'])
+    if len(not_ready) > 0:
+        print('\nNot ready: ' + ', '.join(not_ready))
+
+
+def ai(chat: ChatType,
+       config: Config,
+       number: int
+       ) -> tuple[list[str], dict[str, int]]:
+    """
+    Make AI request with the given chat history and configuration.
+    Return AI response and tokens used.
+    """
+    response = openai.ChatCompletion.create(
+        model=config.openai.model,
+        messages=chat,
+        temperature=config.openai.temperature,
+        max_tokens=config.openai.max_tokens,
+        top_p=config.openai.top_p,
+        n=number,
+        frequency_penalty=config.openai.frequency_penalty,
+        presence_penalty=config.openai.presence_penalty)
+    result = []
+    for choice in response['choices']:  # type: ignore
+        result.append(choice['message']['content'].strip())
+    return result, dict(response['usage'])  # type: ignore

chatmastermind/chat.py

@@ -2,22 +2,17 @@
 Module implementing various chat classes and functions for managing a chat history.
 """
 import shutil
-from pathlib import Path
+import pathlib
 from pprint import PrettyPrinter
 from pydoc import pager
 from dataclasses import dataclass
-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 typing import TypeVar, Type, Optional, ClassVar, Any, Callable
+from .message import Question, Answer, Message, MessageFilter, MessageError, source_code, 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]
-msg_location = Literal['mem', 'disk', 'cache', 'db', 'all']
-
 
 class ChatError(Exception):
     pass
@@ -35,7 +30,7 @@ def print_paged(text: str) -> None:
     pager(text)
 
 
-def read_dir(dir_path: Path,
+def read_dir(dir_path: pathlib.Path,
              glob: Optional[str] = None,
              mfilter: Optional[MessageFilter] = None) -> list[Message]:
     """
@@ -50,32 +45,17 @@ 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.name not in ignored_files  # noqa: W503
-           and file_path.suffix in Message.file_suffixes):  # noqa: W503
+        if file_path.is_file():
             try:
                 message = Message.from_file(file_path, mfilter)
                 if message:
                     messages.append(message)
             except MessageError as e:
-                print(f"WARNING: Skipping message in '{file_path}': {str(e)}")
+                print(f"Error processing message in '{file_path}': {str(e)}")
     return messages
 
 
-def make_file_path(dir_path: Path,
-                   file_suffix: str,
-                   next_fid: Callable[[], int]) -> Path:
-    """
-    Create a file_path for the given directory using the
-    given file_suffix and ID generator function.
-    """
-    file_path = dir_path / f"{next_fid():04d}{file_suffix}"
-    while file_path.exists():
-        file_path = dir_path / f"{next_fid():04d}{file_suffix}"
-    return file_path
-
-
-def write_dir(dir_path: Path,
+def write_dir(dir_path: pathlib.Path,
               messages: list[Message],
               file_suffix: str,
               next_fid: Callable[[], int]) -> None:
@@ -93,26 +73,15 @@ def write_dir(dir_path: Path,
         file_path = message.file_path
         # message has no file_path: create one
         if not file_path:
-            file_path = make_file_path(dir_path, file_suffix, next_fid)
+            fid = next_fid()
+            fname = f"{fid:04d}{file_suffix}"
+            file_path = dir_path / fname
         # file_path does not point to given directory: modify it
         elif not file_path.parent.samefile(dir_path):
             file_path = dir_path / file_path.name
         message.to_file(file_path)
 
 
-def clear_dir(dir_path: Path,
-              glob: Optional[str] = None) -> None:
-    """
-    Deletes all Message files in the given directory.
-    """
-    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.name not in ignored_files  # noqa: W503
-           and file_path.suffix in Message.file_suffixes):  # noqa: W503
-            file_path.unlink(missing_ok=True)
-
-
 @dataclass
 class Chat:
     """
@@ -121,43 +90,14 @@ 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.
-        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:
+    def 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 msg_sort(self, reverse: bool = False) -> None:
+    def sort(self, reverse: bool = False) -> None:
         """
         Sort the messages according to 'Message.msg_id()'.
         """
@@ -167,104 +107,49 @@ 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:
+    def clear(self) -> None:
         """
         Delete all messages.
         """
         self.messages = []
 
-    def msg_add(self, messages: list[Message]) -> None:
+    def add_msgs(self, msgs: list[Message]) -> None:
         """
         Add new messages and sort them if possible.
         """
-        self.messages += messages
-        self.msg_sort()
+        self.messages += msgs
+        self.sort()
 
-    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.msg_sort()
-            for m in reversed(self.messages):
-                if mfilter is None or m.match(mfilter):
-                    return m
-        return None
-
-    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
-        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)]
-
-    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().
-        """
-        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)]
-        self.msg_sort()
-
-    def msg_tags(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> set[Tag]:
+    def tags(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> set[Tag]:
         """
         Get the tags of all messages, optionally filtered by prefix or substring.
         """
         tags: set[Tag] = set()
         for m in self.messages:
             tags |= m.filter_tags(prefix, contain)
-        return set(sorted(tags))
+        return tags
 
-    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.
-        """
-        tags: list[Tag] = []
-        for m in self.messages:
-            tags += [tag for tag in m.filter_tags(prefix, contain)]
-        return {tag: tags.count(tag) for tag in sorted(tags)}
-
-    def tokens(self) -> int:
-        """
-        Returns the nr. of AI language tokens used by all messages in this chat.
-        If unknown, 0 is returned.
-        """
-        return sum(m.tokens() for m in self.messages)
-
-    def print(self, source_code_only: bool = False,
-              with_tags: bool = False, with_files: bool = False,
+    def print(self, dump: bool = False, source_code_only: bool = False,
+              with_tags: bool = False, with_file: bool = False,
               paged: bool = True) -> None:
+        if dump:
+            pp(self)
+            return
         output: list[str] = []
         for message in self.messages:
             if source_code_only:
-                output.append(message.to_str(source_code_only=True))
+                output.extend(source_code(message.question, include_delims=True))
                 continue
-            output.append(message.to_str(with_tags, with_files))
+            output.append('-' * terminal_width())
+            output.append(Question.txt_header)
+            output.append(message.question)
+            if message.answer:
+                output.append(Answer.txt_header)
+                output.append(message.answer)
+            if with_tags:
+                output.append(message.tags_str())
+            if with_file:
+                output.append('FILE: ' + str(message.file_path))
         if paged:
             print_paged('\n'.join(output))
         else:
@@ -283,8 +168,8 @@ class ChatDB(Chat):
 
     default_file_suffix: ClassVar[str] = '.txt'
 
-    cache_path: Path
-    db_path: Path
+    cache_path: pathlib.Path
+    db_path: pathlib.Path
     # a MessageFilter that all messages must match (if given)
     mfilter: Optional[MessageFilter] = None
     file_suffix: str = default_file_suffix
@@ -293,16 +178,12 @@ class ChatDB(Chat):
 
     def __post_init__(self) -> None:
         # contains the latest message ID
-        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()
-        self.validate()
+        self.next_fname = self.db_path / '.next'
 
     @classmethod
     def from_dir(cls: Type[ChatDBInst],
-                 cache_path: Path,
-                 db_path: Path,
+                 cache_path: pathlib.Path,
+                 db_path: pathlib.Path,
                  glob: Optional[str] = None,
                  mfilter: Optional[MessageFilter] = None) -> ChatDBInst:
         """
@@ -322,8 +203,8 @@ class ChatDB(Chat):
 
     @classmethod
     def from_messages(cls: Type[ChatDBInst],
-                      cache_path: Path,
-                      db_path: Path,
+                      cache_path: pathlib.Path,
+                      db_path: pathlib.Path,
                       messages: list[Message],
                       mfilter: Optional[MessageFilter] = None) -> ChatDBInst:
         """
@@ -333,7 +214,7 @@ class ChatDB(Chat):
 
     def get_next_fid(self) -> int:
         try:
-            with open(self.next_path, 'r') as f:
+            with open(self.next_fname, 'r') as f:
                 next_fid = int(f.read()) + 1
             self.set_next_fid(next_fid)
             return next_fid
@@ -342,282 +223,47 @@ class ChatDB(Chat):
             return 1
 
     def set_next_fid(self, fid: int) -> None:
-        with open(self.next_path, 'w') as f:
+        with open(self.next_fname, 'w') as f:
             f.write(f'{fid}')
 
-    def msg_write(self, messages: Optional[list[Message]] = None) -> None:
+    def read_db(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.
-        """
-        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 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.
-        """
-        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_gather(self,
-                   loc: msg_location,
-                   require_file_path: bool = False,
-                   mfilter: Optional[MessageFilter] = None) -> list[Message]:
-        """
-        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
-        * '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.
-        """
-        loc_messages: list[Message] = []
-        if loc 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)))]
-            else:
-                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 loc_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',
-                 ) -> 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 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)
-        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], 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')
-        """
-        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,
-                   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 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
-        * 'db'   : messages in the DB directory
-        * '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)
-        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
-
-    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, 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)
-        # 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 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
-        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,
-                  self.file_suffix,
-                  self.get_next_fid)
-
-    def cache_add(self, messages: list[Message], write: bool = True) -> None:
-        """
-        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):
-            raise ChatError("Can't add new messages with existing file_path")
-        if write:
-            write_dir(self.cache_path,
-                      messages,
-                      self.file_suffix,
-                      self.get_next_fid)
-        else:
-            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.msg_sort()
-
-    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, 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:
-        """
-        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
-        with the same base filename (i. e. 'file_path.name') is already in the list.
+        Reads new messages from the DB directory. New ones are added to the internal list,
+        existing ones are kept or 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.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()
+        self.sort()
 
-    def db_write(self, messages: Optional[list[Message]] = None) -> None:
+    def read_cache(self) -> 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.
-        Does NOT add the messages to the internal list (use 'db_add()' for that)!
+        Reads new messages from the cache directory. New ones are added to the internal list,
+        existing ones are kept or 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_dir(self.db_path,
-                  messages if messages else self.messages,
-                  self.file_suffix,
-                  self.get_next_fid)
+        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()
 
-    def db_add(self, messages: list[Message], write: bool = True) -> None:
+    def write_db(self) -> None:
         """
-        Add NEW messages and set the file_path to the DB directory.
-        Only accepts messages without a file_path.
+        Write all 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.
         """
-        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.msg_sort()
+        write_dir(self.db_path, self.messages, self.file_suffix, self.get_next_fid)
 
-    def db_move(self, message: Message) -> None:
+    def write_cache(self) -> None:
         """
-        Moves the given messages to the db directory.
+        Write all 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.
         """
-        # 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])
+        write_dir(self.cache_path, self.messages, self.file_suffix, self.get_next_fid)

chatmastermind/commands/config.py

@@ -1,20 +0,0 @@
-import argparse
-from pathlib import Path
-from ..configuration import Config
-from ..ai import AI
-from ..ai_factory import create_ai
-
-
-def config_cmd(args: argparse.Namespace) -> None:
-    """
-    Handler for the 'config' command.
-    """
-    if args.create:
-        Config.create_default(Path(args.create))
-    elif args.list_models or args.print_model:
-        config: Config = Config.from_file(args.config)
-        ai: AI = create_ai(args, config)
-        if args.list_models:
-            ai.print_models()
-        else:
-            print(ai.config.model)

chatmastermind/commands/hist.py

@@ -1,23 +0,0 @@
-import argparse
-from pathlib import Path
-from ..configuration import Config
-from ..chat import ChatDB
-from ..message import MessageFilter
-
-
-def hist_cmd(args: argparse.Namespace, config: Config) -> None:
-    """
-    Handler for the 'hist' command.
-    """
-
-    mfilter = MessageFilter(tags_or=args.or_tags,
-                            tags_and=args.and_tags,
-                            tags_not=args.exclude_tags,
-                            question_contains=args.question,
-                            answer_contains=args.answer)
-    chat = ChatDB.from_dir(Path('.'),
-                           Path(config.db),
-                           mfilter=mfilter)
-    chat.print(args.source_code_only,
-               args.with_tags,
-               args.with_files)

chatmastermind/commands/print.py

@@ -1,27 +0,0 @@
-import sys
-import argparse
-from pathlib import Path
-from ..configuration import Config
-from ..message import Message, MessageError
-
-
-def print_cmd(args: argparse.Namespace, config: Config) -> None:
-    """
-    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:
-                print(message.answer)
-            elif message.answer and args.only_source_code:
-                for code in message.answer.source_code():
-                    print(code)
-            else:
-                print(message.to_str())
-    except MessageError:
-        print(f"File is not a valid message: {args.file}")
-        sys.exit(1)

chatmastermind/commands/question.py

@@ -1,123 +0,0 @@
-import argparse
-from pathlib import Path
-from itertools import zip_longest
-from ..configuration import Config
-from ..chat import ChatDB
-from ..message import Message, MessageFilter, MessageError, Question, source_code
-from ..ai_factory import create_ai
-from ..ai import AI, AIResponse
-
-
-def add_file_as_text(question_parts: list[str], file: str) -> None:
-    """
-    Add the given file as plain text to the question part list.
-    If the file is a Message, add the answer.
-    """
-    file_path = Path(file)
-    content: str
-    try:
-        message = Message.from_file(file_path)
-        if message and message.answer:
-            content = message.answer
-    except MessageError:
-        with open(file) as r:
-            content = r.read().strip()
-    if len(content) > 0:
-        question_parts.append(content)
-
-
-def add_file_as_code(question_parts: list[str], file: str) -> None:
-    """
-    Add all source code from the given file. If no code segments can be extracted,
-    the whole content is added as source code segment. If the file is a Message,
-    extract the source code from the answer.
-    """
-    file_path = Path(file)
-    content: str
-    try:
-        message = Message.from_file(file_path)
-        if message and message.answer:
-            content = message.answer
-    except MessageError:
-        with open(file) as r:
-            content = r.read().strip()
-    # extract and add source code
-    code_parts = source_code(content, include_delims=True)
-    if len(code_parts) > 0:
-        question_parts += code_parts
-    else:
-        question_parts.append(f"```\n{content}\n```")
-
-
-def create_message(chat: ChatDB, args: argparse.Namespace) -> Message:
-    """
-    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 []
-    text_files = args.source_text if args.source_text is not None else []
-    code_files = args.source_code if args.source_code is not None else []
-
-    for question, text_file, code_file in zip_longest(question_list, text_files, code_files, fillvalue=None):
-        if question is not None and len(question.strip()) > 0:
-            question_parts.append(question)
-        if text_file is not None and len(text_file) > 0:
-            add_file_as_text(question_parts, text_file)
-        if code_file is not None and len(code_file) > 0:
-            add_file_as_code(question_parts, code_file)
-
-    full_question = '\n\n'.join(question_parts)
-
-    message = Message(question=Question(full_question),
-                      tags=args.output_tags,  # FIXME
-                      ai=args.AI,
-                      model=args.model)
-    chat.cache_add([message])
-    return message
-
-
-def question_cmd(args: argparse.Namespace, config: Config) -> None:
-    """
-    Handler for the 'question' command.
-    """
-    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('.'),
-                           db_path=Path(config.db),
-                           mfilter=mfilter)
-    # if it's a new question, create and store it immediately
-    if args.ask or args.create:
-        message = create_message(chat, args)
-    if args.create:
-        return
-
-    # create the correct AI instance
-    ai: AI = create_ai(args, config)
-    if args.ask:
-        ai.print()
-        chat.print(paged=False)
-        response: AIResponse = ai.request(message,
-                                          chat,
-                                          args.num_answers,  # FIXME
-                                          args.output_tags)  # FIXME
-        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)
-        if response.tokens:
-            print("===============")
-            print(response.tokens)
-    elif args.repeat is not None:
-        lmessage = chat.msg_latest()
-        assert lmessage
-        # TODO: repeat either the last question or the
-        # one(s) given in 'args.repeat' (overwrite
-        # existing ones if 'args.overwrite' is True)
-        pass
-    elif args.process is not None:
-        # TODO: process either all questions without an
-        # answer or the one(s) given in 'args.process'
-        pass

chatmastermind/commands/tags.py

@@ -1,17 +0,0 @@
-import argparse
-from pathlib import Path
-from ..configuration import Config
-from ..chat import ChatDB
-
-
-def tags_cmd(args: argparse.Namespace, config: Config) -> None:
-    """
-    Handler for the 'tags' command.
-    """
-    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)
-        for tag, freq in tags_freq.items():
-            print(f"- {tag}: {freq}")
-    # TODO: add renaming

chatmastermind/configuration.py

@@ -1,167 +1,69 @@
 import yaml
-from pathlib import Path
-from typing import Type, TypeVar, Any, Optional, ClassVar
-from dataclasses import dataclass, asdict, field
+from typing import Type, TypeVar, Any
+from dataclasses import dataclass, asdict
 
 ConfigInst = TypeVar('ConfigInst', bound='Config')
-AIConfigInst = TypeVar('AIConfigInst', bound='AIConfig')
 OpenAIConfigInst = TypeVar('OpenAIConfigInst', bound='OpenAIConfig')
 
 
-supported_ais: list[str] = ['openai']
-default_config_file = '.config.yaml'
-
-
-class ConfigError(Exception):
-    pass
-
-
-def str_presenter(dumper: yaml.Dumper, data: str) -> yaml.ScalarNode:
-    """
-    Changes the YAML dump style to multiline syntax for multiline strings.
-    """
-    if len(data.splitlines()) > 1:
-        return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
-    return dumper.represent_scalar('tag:yaml.org,2002:str', data)
-
-
-yaml.add_representer(str, str_presenter)
-
-
 @dataclass
-class AIConfig:
-    """
-    The base class of all AI configurations.
-    """
-    # the name of the AI the config class represents
-    # -> it's a class variable and thus not part of the
-    #    dataclass constructor
-    name: ClassVar[str]
-    # a user-defined ID for an AI configuration entry
-    ID: str
-    model: str = 'n/a'
-
-    # the name must not be changed
-    def __setattr__(self, name: str, value: Any) -> None:
-        if name == 'name':
-            raise AttributeError("'{name}' is not allowed to be changed")
-        else:
-            super().__setattr__(name, value)
-
-
-@dataclass
-class OpenAIConfig(AIConfig):
+class OpenAIConfig():
     """
     The OpenAI section of the configuration file.
     """
-    name: ClassVar[str] = 'openai'
-
-    # all members have default values, so we can easily create
-    # a default configuration
-    ID: str = 'myopenai'
-    api_key: str = '0123456789'
-    model: str = 'gpt-3.5-turbo-16k'
-    temperature: float = 1.0
-    max_tokens: int = 4000
-    top_p: float = 1.0
-    frequency_penalty: float = 0.0
-    presence_penalty: float = 0.0
-    system: str = 'You are an assistant'
+    api_key: str
+    model: str
+    temperature: float
+    max_tokens: int
+    top_p: float
+    frequency_penalty: float
+    presence_penalty: float
 
     @classmethod
     def from_dict(cls: Type[OpenAIConfigInst], source: dict[str, Any]) -> OpenAIConfigInst:
         """
         Create OpenAIConfig from a dict.
         """
-        res = cls(
+        return cls(
             api_key=str(source['api_key']),
             model=str(source['model']),
             max_tokens=int(source['max_tokens']),
             temperature=float(source['temperature']),
             top_p=float(source['top_p']),
             frequency_penalty=float(source['frequency_penalty']),
-            presence_penalty=float(source['presence_penalty']),
-            system=str(source['system'])
+            presence_penalty=float(source['presence_penalty'])
         )
-        # overwrite default ID if provided
-        if 'ID' in source:
-            res.ID = source['ID']
-        return res
-
-
-def ai_config_instance(name: str, conf_dict: Optional[dict[str, Any]] = None) -> AIConfig:
-    """
-    Creates an AIConfig instance of the given name.
-    """
-    if name.lower() == 'openai':
-        if conf_dict is None:
-            return OpenAIConfig()
-        else:
-            return OpenAIConfig.from_dict(conf_dict)
-    else:
-        raise ConfigError(f"Unknown AI '{name}'")
-
-
-def create_default_ai_configs() -> dict[str, AIConfig]:
-    """
-    Create a dict containing default configurations for all supported AIs.
-    """
-    return {ai_config_instance(name).ID: ai_config_instance(name) for name in supported_ais}
 
 
 @dataclass
-class Config:
+class Config():
     """
     The configuration file structure.
     """
-    # all members have default values, so we can easily create
-    # a default configuration
-    db: str = './db/'
-    ais: dict[str, AIConfig] = field(default_factory=create_default_ai_configs)
+    system: str
+    db: str
+    openai: OpenAIConfig
 
     @classmethod
     def from_dict(cls: Type[ConfigInst], source: dict[str, Any]) -> ConfigInst:
         """
-        Create Config from a dict (with the same format as the config file).
+        Create OpenAIConfig from a dict.
         """
-        # create the correct AI type instances
-        ais: dict[str, AIConfig] = {}
-        for ID, conf in source['ais'].items():
-            # add the AI ID to the config (for easy internal access)
-            conf['ID'] = ID
-            ai_conf = ai_config_instance(conf['name'], conf)
-            ais[ID] = ai_conf
         return cls(
+            system=str(source['system']),
             db=str(source['db']),
-            ais=ais
+            openai=OpenAIConfig.from_dict(source['openai'])
         )
 
-    @classmethod
-    def create_default(self, file_path: Path) -> None:
-        """
-        Creates a default Config in the given file.
-        """
-        conf = Config()
-        conf.to_file(file_path)
-
     @classmethod
     def from_file(cls: Type[ConfigInst], path: str) -> ConfigInst:
         with open(path, 'r') as f:
             source = yaml.load(f, Loader=yaml.FullLoader)
         return cls.from_dict(source)
 
-    def to_file(self, file_path: Path) -> None:
-        # remove the AI name from the config (for a cleaner format)
-        data = self.as_dict()
-        for conf in data['ais'].values():
-            del (conf['ID'])
-        with open(file_path, 'w') as f:
-            yaml.dump(data, f, sort_keys=False)
+    def to_file(self, path: str) -> None:
+        with open(path, 'w') as f:
+            yaml.dump(asdict(self), f, sort_keys=False)
 
     def as_dict(self) -> dict[str, Any]:
-        res = asdict(self)
-        # add the AI name manually (as first element)
-        # (not done by 'asdict' because it's a class variable)
-        for ID, conf in res['ais'].items():
-            res['ais'][ID] = {**{'name': self.ais[ID].name}, **conf}
-        return res
+        return asdict(self)

chatmastermind/main.py

@@ -2,29 +2,138 @@
 # -*- coding: utf-8 -*-
 # vim: set fileencoding=utf-8 :
 
+import yaml
 import sys
 import argcomplete
 import argparse
-from pathlib import Path
+import pathlib
+from .utils import terminal_width, print_tag_args, print_chat_hist, display_source_code, print_tags_frequency, ChatType
+from .storage import save_answers, create_chat_hist, get_tags, get_tags_unique, read_file, dump_data
+from .api_client import ai, openai_api_key, print_models
+from .configuration import Config
+from itertools import zip_longest
 from typing import Any
-from .configuration import Config, default_config_file
-from .message import Message
-from .commands.question import question_cmd
-from .commands.tags import tags_cmd
-from .commands.config import config_cmd
-from .commands.hist import hist_cmd
-from .commands.print import print_cmd
+
+default_config = '.config.yaml'
 
 
 def tags_completer(prefix: str, parsed_args: Any, **kwargs: Any) -> list[str]:
-    config = Config.from_file(parsed_args.config)
-    return list(Message.tags_from_dir(Path(config.db), prefix=prefix))
+    with open(parsed_args.config, 'r') as f:
+        config = yaml.load(f, Loader=yaml.FullLoader)
+    return get_tags_unique(config, prefix)
+
+
+def create_question_with_hist(args: argparse.Namespace,
+                              config: Config,
+                              ) -> tuple[ChatType, str, list[str]]:
+    """
+    Creates the "AI request", including the question and chat history as determined
+    by the specified tags.
+    """
+    tags = args.tags or []
+    extags = args.extags or []
+    otags = args.output_tags or []
+
+    if not args.only_source_code:
+        print_tag_args(tags, extags, otags)
+
+    question_parts = []
+    question_list = args.question if args.question is not None else []
+    source_list = args.source if args.source is not None else []
+
+    for question, source in zip_longest(question_list, source_list, fillvalue=None):
+        if question is not None and source is not None:
+            with open(source) as r:
+                question_parts.append(f"{question}\n\n```\n{r.read().strip()}\n```")
+        elif question is not None:
+            question_parts.append(question)
+        elif source is not None:
+            with open(source) as r:
+                question_parts.append(f"```\n{r.read().strip()}\n```")
+
+    full_question = '\n\n'.join(question_parts)
+    chat = create_chat_hist(full_question, tags, extags, config,
+                            args.match_all_tags, False, False)
+    return chat, full_question, tags
+
+
+def tag_cmd(args: argparse.Namespace, config: Config) -> None:
+    """
+    Handler for the 'tag' command.
+    """
+    if args.list:
+        print_tags_frequency(get_tags(config, None))
+
+
+def config_cmd(args: argparse.Namespace, config: Config) -> None:
+    """
+    Handler for the 'config' command.
+    """
+    if args.list_models:
+        print_models()
+    elif args.print_model:
+        print(config.openai.model)
+    elif args.model:
+        config.openai.model = args.model
+        config.to_file(args.config)
+
+
+def ask_cmd(args: argparse.Namespace, config: Config) -> None:
+    """
+    Handler for the 'ask' command.
+    """
+    if args.max_tokens:
+        config.openai.max_tokens = args.max_tokens
+    if args.temperature:
+        config.openai.temperature = args.temperature
+    if args.model:
+        config.openai.model = args.model
+    chat, question, tags = create_question_with_hist(args, config)
+    print_chat_hist(chat, False, args.only_source_code)
+    otags = args.output_tags or []
+    answers, usage = ai(chat, config, args.number)
+    save_answers(question, answers, tags, otags, config)
+    print("-" * terminal_width())
+    print(f"Usage: {usage}")
+
+
+def hist_cmd(args: argparse.Namespace, config: Config) -> None:
+    """
+    Handler for the 'hist' command.
+    """
+    tags = args.tags or []
+    extags = args.extags or []
+
+    chat = create_chat_hist(None, tags, extags, config,
+                            args.match_all_tags,
+                            args.with_tags,
+                            args.with_files)
+    print_chat_hist(chat, args.dump, args.only_source_code)
+
+
+def print_cmd(args: argparse.Namespace, config: Config) -> None:
+    """
+    Handler for the 'print' command.
+    """
+    fname = pathlib.Path(args.file)
+    if fname.suffix == '.yaml':
+        with open(args.file, 'r') as f:
+            data = yaml.load(f, Loader=yaml.FullLoader)
+    elif fname.suffix == '.txt':
+        data = read_file(fname)
+    else:
+        print(f"Unknown file type: {args.file}")
+        sys.exit(1)
+    if args.only_source_code:
+        display_source_code(data['answer'])
+    else:
+        print(dump_data(data).strip())
 
 
 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_file)
+    parser.add_argument('-c', '--config', help='Config file name.', default=default_config)
 
     # subcommand-parser
     cmdparser = parser.add_subparsers(dest='command',
@@ -34,90 +143,79 @@ def create_parser() -> argparse.ArgumentParser:
 
     # a parent parser for all commands that support tag selection
     tag_parser = argparse.ArgumentParser(add_help=False)
-    tag_arg = tag_parser.add_argument('-t', '--or-tags', nargs='+',
-                                      help='List of tags (one must match)', metavar='OTAGS')
+    tag_arg = tag_parser.add_argument('-t', '--tags', nargs='+',
+                                      help='List of tag names', metavar='TAGS')
     tag_arg.completer = tags_completer  # type: ignore
-    atag_arg = tag_parser.add_argument('-k', '--and-tags', nargs='+',
-                                       help='List of tags (all must match)', metavar='ATAGS')
-    atag_arg.completer = tags_completer  # type: ignore
-    etag_arg = tag_parser.add_argument('-x', '--exclude-tags', nargs='+',
-                                       help='List of tags to exclude', metavar='XTAGS')
-    etag_arg.completer = tags_completer  # type: ignore
+    extag_arg = tag_parser.add_argument('-e', '--extags', nargs='+',
+                                        help='List of tag names to exclude', metavar='EXTAGS')
+    extag_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='OUTTAGS')
+                                       help='List of output tag names, default is input', metavar='OTAGS')
     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')
-    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)
-
-    # 'question' command parser
-    question_cmd_parser = cmdparser.add_parser('question', parents=[tag_parser, ai_parser],
-                                               help="ask, create and process questions.",
-                                               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')
-    question_group.add_argument('-c', '--create', nargs='+', help='Create a question')
-    question_group.add_argument('-r', '--repeat', nargs='*', help='Repeat a question')
-    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',
+    tag_parser.add_argument('-a', '--match-all-tags',
+                            help="All given tags must match when selecting chat history entries",
+                            action='store_true')
+    # enable autocompletion for tags
+
+    # 'ask' command parser
+    ask_cmd_parser = cmdparser.add_parser('ask', parents=[tag_parser],
+                                          help="Ask a question.",
+                                          aliases=['a'])
+    ask_cmd_parser.set_defaults(func=ask_cmd)
+    ask_cmd_parser.add_argument('-q', '--question', nargs='+', help='Question to ask',
+                                required=True)
+    ask_cmd_parser.add_argument('-m', '--max-tokens', help='Max tokens to use', type=int)
+    ask_cmd_parser.add_argument('-T', '--temperature', help='Temperature to use', type=float)
+    ask_cmd_parser.add_argument('-M', '--model', help='Model to use')
+    ask_cmd_parser.add_argument('-n', '--number', help='Number of answers to produce', type=int,
+                                default=1)
+    ask_cmd_parser.add_argument('-s', '--source', nargs='+', help='Source add content of a file to the query')
+    ask_cmd_parser.add_argument('-S', '--only-source-code', help='Add pure source code to the chat history',
                                 action='store_true')
-    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')
 
     # 'hist' command parser
     hist_cmd_parser = cmdparser.add_parser('hist', parents=[tag_parser],
                                            help="Print chat history.",
                                            aliases=['h'])
     hist_cmd_parser.set_defaults(func=hist_cmd)
+    hist_cmd_parser.add_argument('-d', '--dump', help="Print chat history as Python structure",
+                                 action='store_true')
     hist_cmd_parser.add_argument('-w', '--with-tags', help="Print chat history with tags.",
                                  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='Print only source code',
+    hist_cmd_parser.add_argument('-S', '--only-source-code', help='Print only source code',
                                  action='store_true')
-    hist_cmd_parser.add_argument('-A', '--answer', help='Search for answer substring')
-    hist_cmd_parser.add_argument('-Q', '--question', help='Search for question substring')
 
-    # 'tags' command parser
-    tags_cmd_parser = cmdparser.add_parser('tags',
+    # 'tag' command parser
+    tag_cmd_parser = cmdparser.add_parser('tag',
                                           help="Manage tags.",
                                           aliases=['t'])
-    tags_cmd_parser.set_defaults(func=tags_cmd)
-    tags_group = tags_cmd_parser.add_mutually_exclusive_group(required=True)
-    tags_group.add_argument('-l', '--list', help="List all tags and their frequency",
+    tag_cmd_parser.set_defaults(func=tag_cmd)
+    tag_group = tag_cmd_parser.add_mutually_exclusive_group(required=True)
+    tag_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")
-    tags_cmd_parser.add_argument('-c', '--contain', help="Filter tags by contained substring")
 
     # 'config' command parser
     config_cmd_parser = cmdparser.add_parser('config',
                                              help="Manage configuration",
                                              aliases=['c'])
     config_cmd_parser.set_defaults(func=config_cmd)
-    config_cmd_parser.add_argument('-A', '--AI', help='AI ID to use')
     config_group = config_cmd_parser.add_mutually_exclusive_group(required=True)
     config_group.add_argument('-l', '--list-models', help="List all available models",
                               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")
+    config_group.add_argument('-M', '--model', help="Set model in the config file")
 
     # 'print' command parser
     print_cmd_parser = cmdparser.add_parser('print',
-                                            help="Print message files.",
+                                            help="Print files.",
                                             aliases=['p'])
     print_cmd_parser.set_defaults(func=print_cmd)
     print_cmd_parser.add_argument('-f', '--file', help='File to print', required=True)
-    print_cmd_modes = print_cmd_parser.add_mutually_exclusive_group()
-    print_cmd_modes.add_argument('-q', '--question', help='Print only question', 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='Print only source code', action='store_true')
+    print_cmd_parser.add_argument('-S', '--only-source-code', help='Print only source code',
+                                  action='store_true')
 
     argcomplete.autocomplete(parser)
     return parser
@@ -127,11 +225,10 @@ def main() -> int:
     parser = create_parser()
     args = parser.parse_args()
     command = parser.parse_args()
-
-    if command.func == config_cmd:
-        command.func(command)
-    else:
     config = Config.from_file(args.config)
+
+    openai_api_key(config.openai.api_key)
+
     command.func(command, config)
 
     return 0

chatmastermind/message.py

@@ -3,11 +3,9 @@ Module implementing message related functions and classes.
 """
 import pathlib
 import yaml
-import tempfile
-import shutil
 from typing import Type, TypeVar, ClassVar, Optional, Any, Union, Final, Literal, Iterable
 from dataclasses import dataclass, asdict, field
-from .tags import Tag, TagLine, TagError, match_tags, rename_tags
+from .tags import Tag, TagLine, TagError, match_tags
 
 QuestionInst = TypeVar('QuestionInst', bound='Question')
 AnswerInst = TypeVar('AnswerInst', bound='Answer')
@@ -98,7 +96,7 @@ class AILine(str):
 
     def __new__(cls: Type[AILineInst], string: str) -> AILineInst:
         if not string.startswith(cls.prefix):
-            raise MessageError(f"AILine '{string}' is missing prefix '{cls.prefix}'")
+            raise TagError(f"AILine '{string}' is missing prefix '{cls.prefix}'")
         instance = super().__new__(cls, string)
         return instance
 
@@ -118,7 +116,7 @@ class ModelLine(str):
 
     def __new__(cls: Type[ModelLineInst], string: str) -> ModelLineInst:
         if not string.startswith(cls.prefix):
-            raise MessageError(f"ModelLine '{string}' is missing prefix '{cls.prefix}'")
+            raise TagError(f"ModelLine '{string}' is missing prefix '{cls.prefix}'")
         instance = super().__new__(cls, string)
         return instance
 
@@ -130,29 +128,28 @@ class ModelLine(str):
         return cls(' '.join([cls.prefix, model]))
 
 
-class Answer(str):
+class Question(str):
     """
-    A single answer with a defined header.
+    A single question with a defined header.
     """
-    tokens: int = 0  # tokens used by this answer
-    txt_header: ClassVar[str] = '==== ANSWER ===='
-    yaml_key: ClassVar[str] = 'answer'
+    txt_header: ClassVar[str] = '=== QUESTION ==='
+    yaml_key: ClassVar[str] = 'question'
 
-    def __new__(cls: Type[AnswerInst], string: str) -> AnswerInst:
+    def __new__(cls: Type[QuestionInst], string: str) -> QuestionInst:
         """
-        Make sure the answer string does not contain the header as a whole line.
+        Make sure the question string does not contain the header.
         """
-        if cls.txt_header in string.split('\n'):
-            raise MessageError(f"Answer '{string}' contains the header '{cls.txt_header}'")
+        if cls.txt_header in string:
+            raise MessageError(f"Question '{string}' contains the header '{cls.txt_header}'")
         instance = super().__new__(cls, string)
         return instance
 
     @classmethod
-    def from_list(cls: Type[AnswerInst], strings: list[str]) -> AnswerInst:
+    def from_list(cls: Type[QuestionInst], strings: list[str]) -> QuestionInst:
         """
         Build Question from a list of strings. Make sure strings do not contain the header.
         """
-        if cls.txt_header in strings:
+        if any(cls.txt_header in string for string in strings):
             raise MessageError(f"Question contains the header '{cls.txt_header}'")
         instance = super().__new__(cls, '\n'.join(strings).strip())
         return instance
@@ -164,33 +161,28 @@ class Answer(str):
         return source_code(self, include_delims)
 
 
-class Question(str):
+class Answer(str):
     """
-    A single question with a defined header.
+    A single answer with a defined header.
     """
-    tokens: int = 0   # tokens used by this question
-    txt_header: ClassVar[str] = '=== QUESTION ==='
-    yaml_key: ClassVar[str] = 'question'
+    txt_header: ClassVar[str] = '=== ANSWER ==='
+    yaml_key: ClassVar[str] = 'answer'
 
-    def __new__(cls: Type[QuestionInst], string: str) -> QuestionInst:
+    def __new__(cls: Type[AnswerInst], string: str) -> AnswerInst:
         """
-        Make sure the question string does not contain the header as a whole line
-        (also not that from 'Answer', so it's always clear where the answer starts).
+        Make sure the answer string does not contain the header.
         """
-        string_lines = string.split('\n')
-        if cls.txt_header in string_lines:
-            raise MessageError(f"Question '{string}' contains the header '{cls.txt_header}'")
-        if Answer.txt_header in string_lines:
-            raise MessageError(f"Question '{string}' contains the header '{Answer.txt_header}'")
+        if cls.txt_header in string:
+            raise MessageError(f"Answer '{string}' contains the header '{cls.txt_header}'")
         instance = super().__new__(cls, string)
         return instance
 
     @classmethod
-    def from_list(cls: Type[QuestionInst], strings: list[str]) -> QuestionInst:
+    def from_list(cls: Type[AnswerInst], strings: list[str]) -> AnswerInst:
         """
         Build Question from a list of strings. Make sure strings do not contain the header.
         """
-        if cls.txt_header in strings:
+        if any(cls.txt_header in string for string in strings):
             raise MessageError(f"Question contains the header '{cls.txt_header}'")
         instance = super().__new__(cls, '\n'.join(strings).strip())
         return instance
@@ -314,7 +306,7 @@ class Message():
                                           mfilter.tags_not if mfilter else None)
         else:
             message = cls.__from_file_yaml(file_path)
-        if message and (mfilter is None or message.match(mfilter)):
+        if message and (not mfilter or (mfilter and message.match(mfilter))):
             return message
         else:
             return None
@@ -357,20 +349,17 @@ class Message():
             try:
                 pos = fd.tell()
                 ai = AILine(fd.readline()).ai()
-            except MessageError:
+            except TagError:
                 fd.seek(pos)
             # ModelLine (Optional)
             try:
                 pos = fd.tell()
                 model = ModelLine(fd.readline()).model()
-            except MessageError:
+            except TagError:
                 fd.seek(pos)
             # Question and Answer
             text = fd.read().strip().split('\n')
-            try:
             question_idx = text.index(Question.txt_header) + 1
-            except ValueError:
-                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,36 +379,9 @@ class Message():
             * Message.model_yaml_key: str [Optional]
         """
         with open(file_path, "r") as fd:
-            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:
-        """
-        Return the current Message as a string.
-        """
-        output: list[str] = []
-        if source_code_only:
-            # use the source code from answer only
-            if self.answer:
-                output.extend(self.answer.source_code(include_delims=True))
-            return '\n'.join(output) if len(output) > 0 else ''
-        if with_tags:
-            output.append(self.tags_str())
-        if with_file:
-            output.append('FILE: ' + str(self.file_path))
-        output.append(Question.txt_header)
-        output.append(self.question)
-        if self.answer:
-            output.append(Answer.txt_header)
-            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
         """
@@ -450,18 +412,16 @@ class Message():
             * Answer.txt_header
             * Answer
         """
-        with tempfile.NamedTemporaryFile(dir=file_path.parent, prefix=file_path.name, mode="w", delete=False) as temp_fd:
-            temp_file_path = pathlib.Path(temp_fd.name)
+        with open(file_path, "w") as fd:
             if self.tags:
-                temp_fd.write(f'{TagLine.from_set(self.tags)}\n')
+                fd.write(f'{TagLine.from_set(self.tags)}\n')
             if self.ai:
-                temp_fd.write(f'{AILine.from_ai(self.ai)}\n')
+                fd.write(f'{AILine.from_ai(self.ai)}\n')
             if self.model:
-                temp_fd.write(f'{ModelLine.from_model(self.model)}\n')
-            temp_fd.write(f'{Question.txt_header}\n{self.question}\n')
+                fd.write(f'{ModelLine.from_model(self.model)}\n')
+            fd.write(f'{Question.txt_header}\n{self.question}\n')
             if self.answer:
-                temp_fd.write(f'{Answer.txt_header}\n{self.answer}\n')
-        shutil.move(temp_file_path, file_path)
+                fd.write(f'{Answer.txt_header}\n{self.answer}\n')
 
     def __to_file_yaml(self, file_path: pathlib.Path) -> None:
         """
@@ -473,8 +433,7 @@ class Message():
             * Message.ai_yaml_key: str [Optional]
             * Message.model_yaml_key: str [Optional]
         """
-        with tempfile.NamedTemporaryFile(dir=file_path.parent, prefix=file_path.name, mode="w", delete=False) as temp_fd:
-            temp_file_path = pathlib.Path(temp_fd.name)
+        with open(file_path, "w") as fd:
             data: YamlDict = {Question.yaml_key: str(self.question)}
             if self.answer:
                 data[Answer.yaml_key] = str(self.answer)
@@ -484,8 +443,7 @@ class Message():
                 data[self.model_yaml_key] = self.model
             if self.tags:
                 data[self.tags_yaml_key] = sorted([str(tag) for tag in self.tags])
-            yaml.dump(data, temp_fd, sort_keys=False)
-        shutil.move(temp_file_path, file_path)
+            yaml.dump(data, fd, sort_keys=False)
 
     def filter_tags(self, prefix: Optional[str] = None, contain: Optional[str] = None) -> set[Tag]:
         """
@@ -517,7 +475,7 @@ class Message():
         Return True if all attributes match, else False.
         """
         mytags = self.tags or set()
-        if (((mfilter.tags_or is not None or mfilter.tags_and is not None or mfilter.tags_not is not None)
+        if (((mfilter.tags_or or mfilter.tags_and or mfilter.tags_not)
             and not match_tags(mytags, mfilter.tags_or, mfilter.tags_and, mfilter.tags_not))  # noqa: W503
            or (mfilter.ai and (not self.ai or mfilter.ai != self.ai))  # noqa: W503
            or (mfilter.model and (not self.model or mfilter.model != self.model))  # noqa: W503
@@ -532,34 +490,15 @@ class Message():
             return False
         return True
 
-    def rename_tags(self, tags_rename: set[tuple[Tag, Tag]]) -> None:
-        """
-        Renames the given tags. The first tuple element is the old name,
-        the second one is the new name.
-        """
-        if self.tags:
-            self.tags = rename_tags(self.tags, tags_rename)
-
     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
-        messages.
+        Currently this is the file name. The ID is also used for sorting 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")
 
     def as_dict(self) -> dict[str, Any]:
         return asdict(self)
-
-    def tokens(self) -> int:
-        """
-        Returns the nr. of AI language tokens used by this  message.
-        If unknown, 0 is returned.
-        """
-        if self.answer:
-            return self.question.tokens + self.answer.tokens
-        else:
-            return self.question.tokens

chatmastermind/storage.py

@@ -0,0 +1,121 @@
+import yaml
+import io
+import pathlib
+from .utils import terminal_width, append_message, message_to_chat, ChatType
+from .configuration import Config
+from typing import Any, Optional
+
+
+def read_file(fname: pathlib.Path, tags_only: bool = False) -> dict[str, Any]:
+    with open(fname, "r") as fd:
+        tagline = fd.readline().strip().split(':', maxsplit=1)[1].strip()
+        # also support tags separated by ',' (old format)
+        separator = ',' if ',' in tagline else ' '
+        tags = [t.strip() for t in tagline.split(separator)]
+        if tags_only:
+            return {"tags": tags}
+        text = fd.read().strip().split('\n')
+        question_idx = text.index("=== QUESTION ===") + 1
+        answer_idx = text.index("==== ANSWER ====")
+        question = "\n".join(text[question_idx:answer_idx]).strip()
+        answer = "\n".join(text[answer_idx + 1:]).strip()
+        return {"question": question, "answer": answer, "tags": tags,
+                "file": fname.name}
+
+
+def dump_data(data: dict[str, Any]) -> str:
+    with io.StringIO() as fd:
+        fd.write(f'TAGS: {" ".join(data["tags"])}\n')
+        fd.write(f'=== QUESTION ===\n{data["question"]}\n')
+        fd.write(f'==== ANSWER ====\n{data["answer"]}\n')
+        return fd.getvalue()
+
+
+def write_file(fname: str, data: dict[str, Any]) -> None:
+    with open(fname, "w") as fd:
+        fd.write(f'TAGS: {" ".join(data["tags"])}\n')
+        fd.write(f'=== QUESTION ===\n{data["question"]}\n')
+        fd.write(f'==== ANSWER ====\n{data["answer"]}\n')
+
+
+def save_answers(question: str,
+                 answers: list[str],
+                 tags: list[str],
+                 otags: Optional[list[str]],
+                 config: Config
+                 ) -> None:
+    wtags = otags or tags
+    num, inum = 0, 0
+    next_fname = pathlib.Path(str(config.db)) / '.next'
+    try:
+        with open(next_fname, 'r') as f:
+            num = int(f.read())
+    except Exception:
+        pass
+    for answer in answers:
+        num += 1
+        inum += 1
+        title = f'-- ANSWER {inum} '
+        title_end = '-' * (terminal_width() - len(title))
+        print(f'{title}{title_end}')
+        print(answer)
+        write_file(f"{num:04d}.txt", {"question": question, "answer": answer, "tags": wtags})
+    with open(next_fname, 'w') as f:
+        f.write(f'{num}')
+
+
+def create_chat_hist(question: Optional[str],
+                     tags: Optional[list[str]],
+                     extags: Optional[list[str]],
+                     config: Config,
+                     match_all_tags: bool = False,
+                     with_tags: bool = False,
+                     with_file: bool = False
+                     ) -> ChatType:
+    chat: ChatType = []
+    append_message(chat, 'system', str(config.system).strip())
+    for file in sorted(pathlib.Path(str(config.db)).iterdir()):
+        if file.suffix == '.yaml':
+            with open(file, 'r') as f:
+                data = yaml.load(f, Loader=yaml.FullLoader)
+                data['file'] = file.name
+        elif file.suffix == '.txt':
+            data = read_file(file)
+        else:
+            continue
+        data_tags = set(data.get('tags', []))
+        tags_match: bool
+        if match_all_tags:
+            tags_match = not tags or set(tags).issubset(data_tags)
+        else:
+            tags_match = not tags or bool(data_tags.intersection(tags))
+        extags_do_not_match = \
+            not extags or not data_tags.intersection(extags)
+        if tags_match and extags_do_not_match:
+            message_to_chat(data, chat, with_tags, with_file)
+    if question:
+        append_message(chat, 'user', question)
+    return chat
+
+
+def get_tags(config: Config, prefix: Optional[str]) -> list[str]:
+    result = []
+    for file in sorted(pathlib.Path(str(config.db)).iterdir()):
+        if file.suffix == '.yaml':
+            with open(file, 'r') as f:
+                data = yaml.load(f, Loader=yaml.FullLoader)
+        elif file.suffix == '.txt':
+            data = read_file(file, tags_only=True)
+        else:
+            continue
+        for tag in data.get('tags', []):
+            if prefix and len(prefix) > 0:
+                if tag.startswith(prefix):
+                    result.append(tag)
+            else:
+                result.append(tag)
+    return result
+
+
+def get_tags_unique(config: Config, prefix: Optional[str]) -> list[str]:
+    return list(set(get_tags(config, prefix)))

chatmastermind/tags.py

@@ -77,8 +77,7 @@ def match_tags(tags: set[Tag], tags_or: Optional[set[Tag]], tags_and: Optional[s
     i. e. you can select a TagLine if it either contains one of the tags in 'tags_or'
     or all of the tags in 'tags_and' but it must never contain any of the tags in
     'tags_not'. If 'tags_or' and 'tags_and' are 'None', they match all tags (tag
-    exclusion is still done if 'tags_not' is not 'None'). If they are empty (set()),
-    they match no tags.
+    exclusion is still done if 'tags_not' is not 'None').
     """
     required_tags_present = False
     excluded_tags_missing = False

chatmastermind/utils.py

@@ -0,0 +1,85 @@
+import shutil
+from pprint import PrettyPrinter
+from typing import Any
+
+ChatType = list[dict[str, str]]
+
+
+def terminal_width() -> int:
+    return shutil.get_terminal_size().columns
+
+
+def pp(*args: Any, **kwargs: Any) -> None:
+    return PrettyPrinter(width=terminal_width()).pprint(*args, **kwargs)
+
+
+def print_tag_args(tags: list[str], extags: list[str], otags: list[str]) -> None:
+    """
+    Prints the tags specified in the given args.
+    """
+    printed_messages = []
+
+    if tags:
+        printed_messages.append(f"Tags: {' '.join(tags)}")
+    if extags:
+        printed_messages.append(f"Excluding tags: {' '.join(extags)}")
+    if otags:
+        printed_messages.append(f"Output tags: {' '.join(otags)}")
+
+    if printed_messages:
+        print("\n".join(printed_messages))
+        print()
+
+
+def append_message(chat: ChatType,
+                   role: str,
+                   content: str
+                   ) -> None:
+    chat.append({'role': role, 'content': content.replace("''", "'")})
+
+
+def message_to_chat(message: dict[str, str],
+                    chat: ChatType,
+                    with_tags: bool = False,
+                    with_file: bool = False
+                    ) -> None:
+    append_message(chat, 'user', message['question'])
+    append_message(chat, 'assistant', message['answer'])
+    if with_tags:
+        tags = " ".join(message['tags'])
+        append_message(chat, 'tags', tags)
+    if with_file:
+        append_message(chat, 'file', message['file'])
+
+
+def display_source_code(content: str) -> None:
+    try:
+        content_start = content.index('```')
+        content_end = content.rindex('```')
+        if content_start + 3 < content_end:
+            print(content[content_start + 3:content_end].strip())
+    except ValueError:
+        pass
+
+
+def print_chat_hist(chat: ChatType, dump: bool = False, source_code: bool = False) -> None:
+    if dump:
+        pp(chat)
+        return
+    for message in chat:
+        text_too_long = len(message['content']) > terminal_width() - len(message['role']) - 2
+        if source_code:
+            display_source_code(message['content'])
+            continue
+        if message['role'] == 'user':
+            print('-' * terminal_width())
+        if text_too_long:
+            print(f"{message['role'].upper()}:")
+            print(message['content'])
+        else:
+            print(f"{message['role'].upper()}: {message['content']}")
+
+
+def print_tags_frequency(tags: list[str]) -> None:
+    for tag in sorted(set(tags)):
+        print(f"- {tag}: {tags.count(tag)}")

hooks/gitea_cmm_hook.php

@@ -1,56 +0,0 @@
-<?php
-
-$secret_key = '123';
-
-// check for POST request
-if ($_SERVER['REQUEST_METHOD'] != 'POST') {
-    error_log('FAILED - not POST - '. $_SERVER['REQUEST_METHOD']);
-    exit();
-}
-
-// get content type
-$content_type = isset($_SERVER['CONTENT_TYPE']) ? strtolower(trim($_SERVER['CONTENT_TYPE'])) : '';
-
-if ($content_type != 'application/json') {
-    error_log('FAILED - not application/json - '. $content_type);
-    exit();
-}
-
-// get payload
-$payload = trim(file_get_contents("php://input"));
-
-if (empty($payload)) {
-    error_log('FAILED - no payload');
-    exit();
-}
-
-// get header signature
-$header_signature = isset($_SERVER['HTTP_X_GITEA_SIGNATURE']) ? $_SERVER['HTTP_X_GITEA_SIGNATURE'] : '';
-
-if (empty($header_signature)) {
-    error_log('FAILED - header signature missing');
-    exit();
-}
-
-// calculate payload signature
-$payload_signature = hash_hmac('sha256', $payload, $secret_key, false);
-
-// check payload signature against header signature
-if ($header_signature !== $payload_signature) {
-    error_log('FAILED - payload signature');
-    exit();
-}
-
-// convert json to array
-$decoded = json_decode($payload, true);
-
-// check for json decode errors
-if (json_last_error() !== JSON_ERROR_NONE) {
-    error_log('FAILED - json decode - '. json_last_error());
-    exit();
-}
-
-// success, do something
-$output = shell_exec('/home/kaizen/repos/ChatMastermind/hooks/push_hook.sh');
-echo "$output";
-?>

hooks/push_hook.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/bash
-
-. /home/kaizen/.bashrc
-set -e
-cd /home/kaizen/repos/ChatMastermind
-git pull
-pre-commit run -a
-pytest

setup.py

@@ -12,7 +12,7 @@ setup(
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/ok2/ChatMastermind",
-    packages=find_packages() + ["chatmastermind.ais", "chatmastermind.commands"],
+    packages=find_packages(),
     classifiers=[
         "Development Status :: 3 - Alpha",
         "Environment :: Console",
@@ -32,7 +32,7 @@ setup(
         "openai",
         "PyYAML",
         "argcomplete",
-        "pytest",
+        "pytest"
     ],
     python_requires=">=3.9",
     test_suite="tests",

tests/test_ai_factory.py

@@ -1,48 +0,0 @@
-import argparse
-import unittest
-from unittest.mock import MagicMock
-from chatmastermind.ai_factory import create_ai
-from chatmastermind.configuration import Config
-from chatmastermind.ai import AIError
-from chatmastermind.ais.openai import OpenAI
-
-
-class TestCreateAI(unittest.TestCase):
-    def setUp(self) -> None:
-        self.args = MagicMock(spec=argparse.Namespace)
-        self.args.AI = 'myopenai'
-        self.args.model = None
-        self.args.max_tokens = None
-        self.args.temperature = None
-
-    def test_create_ai_from_args(self) -> None:
-        # Create an AI with the default configuration
-        config = Config()
-        self.args.AI = 'myopenai'
-        ai = create_ai(self.args, config)
-        self.assertIsInstance(ai, OpenAI)
-
-    def test_create_ai_from_default(self) -> None:
-        self.args.AI = None
-        # Create an AI with the default configuration
-        config = Config()
-        ai = create_ai(self.args, config)
-        self.assertIsInstance(ai, OpenAI)
-
-    def test_create_empty_ai_error(self) -> None:
-        self.args.AI = None
-        # Create Config with empty AIs
-        config = Config()
-        config.ais = {}
-        # Call create_ai function and assert that it raises AIError
-        with self.assertRaises(AIError):
-            create_ai(self.args, config)
-
-    def test_create_unsupported_ai_error(self) -> None:
-        # Mock argparse.Namespace with ai='invalid_ai'
-        self.args.AI = 'invalid_ai'
-        # Create default Config
-        config = Config()
-        # Call create_ai function and assert that it raises AIError
-        with self.assertRaises(AIError):
-            create_ai(self.args, config)

tests/test_ais_openai.py

@@ -1,81 +0,0 @@
-import unittest
-from unittest import mock
-from chatmastermind.ais.openai import OpenAI
-from chatmastermind.message import Message, Question, Answer
-from chatmastermind.chat import Chat
-from chatmastermind.ai import AIResponse, Tokens
-from chatmastermind.configuration import OpenAIConfig
-
-
-class OpenAITest(unittest.TestCase):
-
-    @mock.patch('openai.ChatCompletion.create')
-    def test_request(self, mock_create: mock.MagicMock) -> None:
-        # Create a test instance of OpenAI
-        config = OpenAIConfig()
-        openai = OpenAI(config)
-
-        # Set up the mock response from openai.ChatCompletion.create
-        mock_response = {
-            'choices': [
-                {
-                    'message': {
-                        'content': 'Answer 1'
-                    }
-                },
-                {
-                    'message': {
-                        'content': 'Answer 2'
-                    }
-                }
-            ],
-            'usage': {
-                'prompt_tokens': 10,
-                'completion_tokens': 20,
-                'total_tokens': 30
-            }
-        }
-        mock_create.return_value = mock_response
-
-        # Create test data
-        question = Message(Question('Question'))
-        chat = Chat([
-            Message(Question('Question 1'), answer=Answer('Answer 1')),
-            Message(Question('Question 2'), answer=Answer('Answer 2')),
-            # add message without an answer -> expect to be skipped
-            Message(Question('Question 3'))
-        ])
-
-        # Make the request
-        response = openai.request(question, chat, num_answers=2)
-
-        # Assert the AIResponse
-        self.assertIsInstance(response, AIResponse)
-        self.assertEqual(len(response.messages), 2)
-        self.assertEqual(response.messages[0].answer, 'Answer 1')
-        self.assertEqual(response.messages[1].answer, 'Answer 2')
-        self.assertIsNotNone(response.tokens)
-        self.assertIsInstance(response.tokens, Tokens)
-        assert response.tokens
-        self.assertEqual(response.tokens.prompt, 10)
-        self.assertEqual(response.tokens.completion, 20)
-        self.assertEqual(response.tokens.total, 30)
-
-        # Assert the mock call to openai.ChatCompletion.create
-        mock_create.assert_called_once_with(
-            model=f'{config.model}',
-            messages=[
-                {'role': 'system', 'content': f'{config.system}'},
-                {'role': 'user', 'content': 'Question 1'},
-                {'role': 'assistant', 'content': 'Answer 1'},
-                {'role': 'user', 'content': 'Question 2'},
-                {'role': 'assistant', 'content': 'Answer 2'},
-                {'role': 'user', 'content': 'Question'}
-            ],
-            temperature=config.temperature,
-            max_tokens=config.max_tokens,
-            top_p=config.top_p,
-            n=2,
-            frequency_penalty=config.frequency_penalty,
-            presence_penalty=config.presence_penalty
-        )

tests/test_chat.py

@@ -1,128 +1,72 @@
-import unittest
 import pathlib
 import tempfile
 import time
-import yaml
 from io import StringIO
 from unittest.mock import patch
 from chatmastermind.tags import TagLine
 from chatmastermind.message import Message, Question, Answer, Tag, MessageFilter
-from chatmastermind.chat import Chat, ChatDB, ChatError
+from chatmastermind.chat import Chat, ChatDB, terminal_width
+from .test_main import CmmTestCase
 
 
-class TestChat(unittest.TestCase):
+class TestChat(CmmTestCase):
     def setUp(self) -> None:
         self.chat = Chat([])
         self.message1 = Message(Question('Question 1'),
                                 Answer('Answer 1'),
-                                {Tag('atag1'), Tag('btag2')},
+                                {Tag('atag1')},
                                 file_path=pathlib.Path('0001.txt'))
         self.message2 = Message(Question('Question 2'),
                                 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])
-        self.chat.msg_filter(MessageFilter(answer_contains='Answer 1'))
+        self.chat.add_msgs([self.message1, self.message2])
+        self.chat.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.msg_add([self.message2, self.message1])
-        self.chat.msg_sort()
+        self.chat.add_msgs([self.message2, self.message1])
+        self.chat.sort()
         self.assertEqual(self.chat.messages[0].question, 'Question 1')
         self.assertEqual(self.chat.messages[1].question, 'Question 2')
-        self.chat.msg_sort(reverse=True)
+        self.chat.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.msg_add([self.message1])
-        self.chat.msg_clear()
+        self.chat.add_msgs([self.message1])
+        self.chat.clear()
         self.assertEqual(len(self.chat.messages), 0)
 
-    def test_add_messages(self) -> None:
-        self.chat.msg_add([self.message1, self.message2])
+    def test_add_msgs(self) -> None:
+        self.chat.add_msgs([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.msg_add([self.message1, self.message2])
-        tags_all = self.chat.msg_tags()
+        self.chat.add_msgs([self.message1, self.message2])
+        tags_all = self.chat.tags()
         self.assertSetEqual(tags_all, {Tag('atag1'), Tag('btag2')})
-        tags_pref = self.chat.msg_tags(prefix='a')
+        tags_pref = self.chat.tags(prefix='a')
         self.assertSetEqual(tags_pref, {Tag('atag1')})
-        tags_cont = self.chat.msg_tags(contain='2')
+        tags_cont = self.chat.tags(contain='2')
         self.assertSetEqual(tags_cont, {Tag('btag2')})
 
-    def test_tags_frequency(self) -> None:
-        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.msg_add([self.message1, self.message2])
-        msgs = self.chat.msg_find(['0001.txt'])
-        self.assertListEqual(msgs, [self.message1])
-        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.msg_add([message3])
-        # find new Message by full path
-        msgs = self.chat.msg_find(['/foo/bla/0003.txt'])
-        self.assertListEqual(msgs, [message3])
-        # find Message with full path only by filename
-        msgs = self.chat.msg_find(['0003.txt'])
-        self.assertListEqual(msgs, [message3])
-        # remove last message
-        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.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.msg_add([self.message1, self.message2])
+        self.chat.add_msgs([self.message1, self.message2])
         self.chat.print(paged=False)
-        expected_output = f"""{Question.txt_header}
+        expected_output = f"""{'-'*terminal_width()}
+{Question.txt_header}
 Question 1
 {Answer.txt_header}
 Answer 1
+{'-'*terminal_width()}
 {Question.txt_header}
 Question 2
 {Answer.txt_header}
@@ -132,25 +76,27 @@ Answer 2
 
     @patch('sys.stdout', new_callable=StringIO)
     def test_print_with_tags_and_file(self, mock_stdout: StringIO) -> None:
-        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
+        self.chat.add_msgs([self.message1, self.message2])
+        self.chat.print(paged=False, with_tags=True, with_file=True)
+        expected_output = f"""{'-'*terminal_width()}
 {Question.txt_header}
 Question 1
 {Answer.txt_header}
 Answer 1
-{TagLine.prefix} btag2
-FILE: 0002.txt
+{TagLine.prefix} atag1
+FILE: 0001.txt
+{'-'*terminal_width()}
 {Question.txt_header}
 Question 2
 {Answer.txt_header}
 Answer 2
+{TagLine.prefix} btag2
+FILE: 0002.txt
 """
         self.assertEqual(mock_stdout.getvalue(), expected_output)
 
 
-class TestChatDB(unittest.TestCase):
+class TestChatDB(CmmTestCase):
     def setUp(self) -> None:
         self.db_path = tempfile.TemporaryDirectory()
         self.cache_path = tempfile.TemporaryDirectory()
@@ -176,45 +122,13 @@ class TestChatDB(unittest.TestCase):
         self.message2.to_file(pathlib.Path(self.db_path.name, '0002.yaml'))
         self.message3.to_file(pathlib.Path(self.db_path.name, '0003.txt'))
         self.message4.to_file(pathlib.Path(self.db_path.name, '0004.yaml'))
-        # make the next FID match the current state
-        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 [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()
         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:
+    def test_chat_db_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)
@@ -230,7 +144,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[3].file_path,
                          pathlib.Path(self.db_path.name, '0004.yaml'))
 
-    def test_from_dir_glob(self) -> None:
+    def test_chat_db_from_dir_glob(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name),
                                   glob='*.txt')
@@ -242,25 +156,7 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[1].file_path,
                          pathlib.Path(self.db_path.name, '0003.txt'))
 
-    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')}))
-        self.assertEqual(len(chat_db.messages), 1)
-        self.assertEqual(chat_db.cache_path, pathlib.Path(self.cache_path.name))
-        self.assertEqual(chat_db.db_path, pathlib.Path(self.db_path.name))
-        self.assertEqual(chat_db.messages[0].file_path,
-                         pathlib.Path(self.db_path.name, '0001.txt'))
-
-    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(),
-                                                        tags_and=set(),
-                                                        tags_not=set()))
-        self.assertEqual(len(chat_db.messages), 0)
-
-    def test_from_dir_filter_answer(self) -> None:
+    def test_chat_db_filter(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'))
@@ -271,7 +167,7 @@ class TestChatDB(unittest.TestCase):
                          pathlib.Path(self.db_path.name, '0002.yaml'))
         self.assertEqual(chat_db.messages[0].answer, 'Answer 2')
 
-    def test_from_messages(self) -> None:
+    def test_chat_db_from_messges(self) -> None:
         chat_db = ChatDB.from_messages(pathlib.Path(self.cache_path.name),
                                        pathlib.Path(self.db_path.name),
                                        messages=[self.message1, self.message2,
@@ -280,35 +176,16 @@ 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_fids(self) -> None:
+    def test_chat_db_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)
-        self.assertEqual(chat_db.get_next_fid(), 6)
-        self.assertEqual(chat_db.get_next_fid(), 7)
-        with open(chat_db.next_path, 'r') as f:
-            self.assertEqual(f.read(), '7')
+        self.assertEqual(chat_db.get_next_fid(), 1)
+        self.assertEqual(chat_db.get_next_fid(), 2)
+        self.assertEqual(chat_db.get_next_fid(), 3)
+        with open(chat_db.next_fname, 'r') as f:
+            self.assertEqual(f.read(), '3')
 
-    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:
+    def test_chat_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))
@@ -319,9 +196,9 @@ 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.cache_write()
+        chat_db.write_cache()
         # check if the written files are in the cache directory
-        cache_dir_files = self.message_list(self.cache_path)
+        cache_dir_files = list(pathlib.Path(self.cache_path.name).glob('*'))
         self.assertEqual(len(cache_dir_files), 4)
         self.assertIn(pathlib.Path(self.cache_path.name, '0001.txt'), cache_dir_files)
         self.assertIn(pathlib.Path(self.cache_path.name, '0002.yaml'), cache_dir_files)
@@ -334,14 +211,14 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[3].file_path, pathlib.Path(self.cache_path.name, '0004.yaml'))
 
         # check the timestamp of the files in the DB directory
-        db_dir_files = self.message_list(self.db_path)
+        db_dir_files = list(pathlib.Path(self.db_path.name).glob('*'))
         self.assertEqual(len(db_dir_files), 4)
         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.db_write()
+        chat_db.write_db()
         # check if the written files are in the DB directory
-        db_dir_files = self.message_list(self.db_path)
+        db_dir_files = list(pathlib.Path(self.db_path.name).glob('*'))
         self.assertEqual(len(db_dir_files), 4)
         self.assertIn(pathlib.Path(self.db_path.name, '0001.txt'), db_dir_files)
         self.assertIn(pathlib.Path(self.db_path.name, '0002.yaml'), db_dir_files)
@@ -355,287 +232,3 @@ class TestChatDB(unittest.TestCase):
         self.assertEqual(chat_db.messages[1].file_path, pathlib.Path(self.db_path.name, '0002.yaml'))
         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_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))
-        self.assertEqual(len(chat_db.messages), 4)
-
-        # create 2 new files in the DB directory
-        new_message1 = Message(Question('Question 5'),
-                               Answer('Answer 5'),
-                               {Tag('tag5')})
-        new_message2 = Message(Question('Question 6'),
-                               Answer('Answer 6'),
-                               {Tag('tag6')})
-        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.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'))
-
-        # create 2 new files in the cache directory
-        new_message3 = Message(Question('Question 7'),
-                               Answer('Answer 5'),
-                               {Tag('tag7')})
-        new_message4 = Message(Question('Question 8'),
-                               Answer('Answer 6'),
-                               {Tag('tag8')})
-        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.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'))
-        self.assertEqual(chat_db.messages[7].file_path, pathlib.Path(self.cache_path.name, '0008.yaml'))
-        # an the old ones keep their path (since they have not been replaced)
-        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'))
-
-        # now overwrite two messages in the DB directory
-        new_message1.question = Question('New Question 1')
-        new_message2.question = Question('New Question 2')
-        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.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')
-        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'))
-
-        # now write the messages from the cache to the DB directory
-        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.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'))
-        self.assertEqual(chat_db.messages[7].file_path, pathlib.Path(self.db_path.name, '0008.yaml'))
-
-    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))
-        # check that Message.file_path is correct
-        self.assertEqual(chat_db.messages[0].file_path, pathlib.Path(self.db_path.name, '0001.txt'))
-        self.assertEqual(chat_db.messages[1].file_path, pathlib.Path(self.db_path.name, '0002.yaml'))
-        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'))
-
-        # write the messages to the cache directory
-        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.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)
-        self.assertIn(pathlib.Path(self.db_path.name, '0002.yaml'), db_dir_files)
-        self.assertIn(pathlib.Path(self.db_path.name, '0003.txt'), db_dir_files)
-        self.assertIn(pathlib.Path(self.db_path.name, '0004.yaml'), db_dir_files)
-
-        # add a new message with empty file_path
-        message_empty = Message(question=Question("What the hell am I doing here?"),
-                                answer=Answer("You don't belong here!"))
-        # and one for the cache dir
-        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.msg_add([message_empty, message_cache])
-
-        # clear the cache and check the cache dir
-        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
-        self.assertEqual(len(chat_db.messages), 5)
-        db_dir_files = self.message_list(self.db_path)
-        self.assertEqual(len(db_dir_files), 4)
-        # 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_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))
-
-        db_dir_files = self.message_list(self.db_path)
-        self.assertEqual(len(db_dir_files), 4)
-
-        # add new messages to the cache dir
-        message1 = Message(question=Question("Question 1"),
-                           answer=Answer("Answer 1"))
-        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]
-        cache_dir_files = self.message_list(self.cache_path)
-        self.assertEqual(len(cache_dir_files), 1)
-
-        # add new messages to the DB dir
-        message2 = Message(question=Question("Question 2"),
-                           answer=Answer("Answer 2"))
-        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]
-        db_dir_files = self.message_list(self.db_path)
-        self.assertEqual(len(db_dir_files), 5)
-
-        with self.assertRaises(ChatError):
-            chat_db.cache_add([Message(Question("?"), file_path=pathlib.Path("foo"))])
-
-    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))
-
-        db_dir_files = self.message_list(self.db_path)
-        self.assertEqual(len(db_dir_files), 4)
-        cache_dir_files = self.message_list(self.cache_path)
-        self.assertEqual(len(cache_dir_files), 0)
-
-        # try to write a message without a valid file_path
-        message = Message(question=Question("Question 1"),
-                          answer=Answer("Answer 1"))
-        with self.assertRaises(ChatError):
-            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.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)
-
-    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))
-
-        db_dir_files = self.message_list(self.db_path)
-        self.assertEqual(len(db_dir_files), 4)
-        cache_dir_files = self.message_list(self.cache_path)
-        self.assertEqual(len(cache_dir_files), 0)
-
-        message = chat_db.messages[0]
-        message.answer = Answer("New answer")
-        # update message without writing
-        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.db_read()
-        self.assertEqual(chat_db.messages[0].answer, Answer("Answer 1"))
-        # now check with writing (message should be overwritten)
-        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.msg_update([message1])
-
-    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)], 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)], 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)], 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, 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(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(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(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(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)

tests/test_configuration.py

@@ -1,160 +0,0 @@
-import os
-import unittest
-import yaml
-from tempfile import NamedTemporaryFile
-from pathlib import Path
-from typing import cast
-from chatmastermind.configuration import AIConfig, OpenAIConfig, ConfigError, ai_config_instance, Config
-
-
-class TestAIConfigInstance(unittest.TestCase):
-    def test_ai_config_instance_with_valid_name_should_return_instance_with_default_values(self) -> None:
-        ai_config = cast(OpenAIConfig, ai_config_instance('openai'))
-        ai_reference = OpenAIConfig()
-        self.assertEqual(ai_config.ID, ai_reference.ID)
-        self.assertEqual(ai_config.name, ai_reference.name)
-        self.assertEqual(ai_config.api_key, ai_reference.api_key)
-        self.assertEqual(ai_config.system, ai_reference.system)
-        self.assertEqual(ai_config.model, ai_reference.model)
-        self.assertEqual(ai_config.temperature, ai_reference.temperature)
-        self.assertEqual(ai_config.max_tokens, ai_reference.max_tokens)
-        self.assertEqual(ai_config.top_p, ai_reference.top_p)
-        self.assertEqual(ai_config.frequency_penalty, ai_reference.frequency_penalty)
-        self.assertEqual(ai_config.presence_penalty, ai_reference.presence_penalty)
-
-    def test_ai_config_instance_with_valid_name_and_configuration_should_return_instance_with_custom_values(self) -> None:
-        conf_dict = {
-            'system': 'Custom system',
-            'api_key': '9876543210',
-            'model': 'custom_model',
-            'max_tokens': 5000,
-            'temperature': 0.5,
-            'top_p': 0.8,
-            'frequency_penalty': 0.7,
-            'presence_penalty': 0.2
-        }
-        ai_config = cast(OpenAIConfig, ai_config_instance('openai', conf_dict))
-        self.assertEqual(ai_config.system, 'Custom system')
-        self.assertEqual(ai_config.api_key, '9876543210')
-        self.assertEqual(ai_config.model, 'custom_model')
-        self.assertEqual(ai_config.max_tokens, 5000)
-        self.assertAlmostEqual(ai_config.temperature, 0.5)
-        self.assertAlmostEqual(ai_config.top_p, 0.8)
-        self.assertAlmostEqual(ai_config.frequency_penalty, 0.7)
-        self.assertAlmostEqual(ai_config.presence_penalty, 0.2)
-
-    def test_ai_config_instance_with_invalid_name_should_raise_config_error(self) -> None:
-        with self.assertRaises(ConfigError):
-            ai_config_instance('invalid_name')
-
-
-class TestConfig(unittest.TestCase):
-    def setUp(self) -> None:
-        self.test_file = NamedTemporaryFile(delete=False)
-
-    def tearDown(self) -> None:
-        os.remove(self.test_file.name)
-
-    def test_from_dict_should_create_config_from_dict(self) -> None:
-        source_dict = {
-            'db': './test_db/',
-            'ais': {
-                'myopenai': {
-                    'name': 'openai',
-                    'system': 'Custom system',
-                    'api_key': '9876543210',
-                    'model': 'custom_model',
-                    'max_tokens': 5000,
-                    'temperature': 0.5,
-                    'top_p': 0.8,
-                    'frequency_penalty': 0.7,
-                    'presence_penalty': 0.2
-                }
-            }
-        }
-        config = Config.from_dict(source_dict)
-        self.assertEqual(config.db, './test_db/')
-        self.assertEqual(len(config.ais), 1)
-        self.assertEqual(config.ais['myopenai'].name, 'openai')
-        self.assertEqual(cast(OpenAIConfig, config.ais['myopenai']).system, 'Custom system')
-        # check that 'ID' has been added
-        self.assertEqual(config.ais['myopenai'].ID, 'myopenai')
-
-    def test_create_default_should_create_default_config(self) -> None:
-        Config.create_default(Path(self.test_file.name))
-        with open(self.test_file.name, 'r') as f:
-            default_config = yaml.load(f, Loader=yaml.FullLoader)
-        config_reference = Config()
-        self.assertEqual(default_config['db'], config_reference.db)
-
-    def test_from_file_should_load_config_from_file(self) -> None:
-        source_dict = {
-            'db': './test_db/',
-            'ais': {
-                'default': {
-                    'name': 'openai',
-                    'system': 'Custom system',
-                    'api_key': '9876543210',
-                    'model': 'custom_model',
-                    'max_tokens': 5000,
-                    'temperature': 0.5,
-                    'top_p': 0.8,
-                    'frequency_penalty': 0.7,
-                    'presence_penalty': 0.2
-                }
-            }
-        }
-        with open(self.test_file.name, 'w') as f:
-            yaml.dump(source_dict, f)
-        config = Config.from_file(self.test_file.name)
-        self.assertIsInstance(config, Config)
-        self.assertEqual(config.db, './test_db/')
-        self.assertEqual(len(config.ais), 1)
-        self.assertIsInstance(config.ais['default'], AIConfig)
-        self.assertEqual(cast(OpenAIConfig, config.ais['default']).system, 'Custom system')
-
-    def test_to_file_should_save_config_to_file(self) -> None:
-        config = Config(
-            db='./test_db/',
-            ais={
-                'myopenai': OpenAIConfig(
-                    ID='myopenai',
-                    system='Custom system',
-                    api_key='9876543210',
-                    model='custom_model',
-                    max_tokens=5000,
-                    temperature=0.5,
-                    top_p=0.8,
-                    frequency_penalty=0.7,
-                    presence_penalty=0.2
-                )
-            }
-        )
-        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['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 = {
-            'db': './test_db/',
-            'ais': {
-                'default': {
-                    'name': 'foobla',
-                    'system': 'Custom system',
-                    'api_key': '9876543210',
-                    'model': 'custom_model',
-                    'max_tokens': 5000,
-                    'temperature': 0.5,
-                    'top_p': 0.8,
-                    'frequency_penalty': 0.7,
-                    'presence_penalty': 0.2
-                }
-            }
-        }
-        with open(self.test_file.name, 'w') as f:
-            yaml.dump(source_dict, f)
-        with self.assertRaises(ConfigError):
-            Config.from_file(self.test_file.name)

tests/test_main.py

@@ -0,0 +1,233 @@
+import unittest
+import io
+import pathlib
+import argparse
+from chatmastermind.utils import terminal_width
+from chatmastermind.main import create_parser, ask_cmd
+from chatmastermind.api_client import ai
+from chatmastermind.configuration import Config
+from chatmastermind.storage import create_chat_hist, save_answers, dump_data
+from unittest import mock
+from unittest.mock import patch, MagicMock, Mock, ANY
+
+
+class CmmTestCase(unittest.TestCase):
+    """
+    Base class for all cmm testcases.
+    """
+    def dummy_config(self, db: str) -> Config:
+        """
+        Creates a dummy configuration.
+        """
+        return Config.from_dict(
+            {'system': 'dummy_system',
+             'db': db,
+             'openai': {'api_key': 'dummy_key',
+                        'model': 'dummy_model',
+                        'max_tokens': 4000,
+                        'temperature': 1.0,
+                        'top_p': 1,
+                        'frequency_penalty': 0,
+                        'presence_penalty': 0}}
+        )
+
+
+class TestCreateChat(CmmTestCase):
+
+    def setUp(self) -> None:
+        self.config = self.dummy_config(db='test_files')
+        self.question = "test question"
+        self.tags = ['test_tag']
+
+    @patch('os.listdir')
+    @patch('pathlib.Path.iterdir')
+    @patch('builtins.open')
+    def test_create_chat_with_tags(self, open_mock: MagicMock, iterdir_mock: MagicMock, listdir_mock: MagicMock) -> None:
+        listdir_mock.return_value = ['testfile.txt']
+        iterdir_mock.return_value = [pathlib.Path(x) for x in listdir_mock.return_value]
+        open_mock.return_value.__enter__.return_value = io.StringIO(dump_data(
+            {'question': 'test_content', 'answer': 'some answer',
+             'tags': ['test_tag']}))
+
+        test_chat = create_chat_hist(self.question, self.tags, None, self.config)
+
+        self.assertEqual(len(test_chat), 4)
+        self.assertEqual(test_chat[0],
+                         {'role': 'system', 'content': self.config.system})
+        self.assertEqual(test_chat[1],
+                         {'role': 'user', 'content': 'test_content'})
+        self.assertEqual(test_chat[2],
+                         {'role': 'assistant', 'content': 'some answer'})
+        self.assertEqual(test_chat[3],
+                         {'role': 'user', 'content': self.question})
+
+    @patch('os.listdir')
+    @patch('pathlib.Path.iterdir')
+    @patch('builtins.open')
+    def test_create_chat_with_other_tags(self, open_mock: MagicMock, iterdir_mock: MagicMock, listdir_mock: MagicMock) -> None:
+        listdir_mock.return_value = ['testfile.txt']
+        iterdir_mock.return_value = [pathlib.Path(x) for x in listdir_mock.return_value]
+        open_mock.return_value.__enter__.return_value = io.StringIO(dump_data(
+            {'question': 'test_content', 'answer': 'some answer',
+             'tags': ['other_tag']}))
+
+        test_chat = create_chat_hist(self.question, self.tags, None, self.config)
+
+        self.assertEqual(len(test_chat), 2)
+        self.assertEqual(test_chat[0],
+                         {'role': 'system', 'content': self.config.system})
+        self.assertEqual(test_chat[1],
+                         {'role': 'user', 'content': self.question})
+
+    @patch('os.listdir')
+    @patch('pathlib.Path.iterdir')
+    @patch('builtins.open')
+    def test_create_chat_without_tags(self, open_mock: MagicMock, iterdir_mock: MagicMock, listdir_mock: MagicMock) -> None:
+        listdir_mock.return_value = ['testfile.txt', 'testfile2.txt']
+        iterdir_mock.return_value = [pathlib.Path(x) for x in listdir_mock.return_value]
+        open_mock.side_effect = (
+            io.StringIO(dump_data({'question': 'test_content',
+                                   'answer': 'some answer',
+                                   'tags': ['test_tag']})),
+            io.StringIO(dump_data({'question': 'test_content2',
+                                   'answer': 'some answer2',
+                                   'tags': ['test_tag2']})),
+        )
+
+        test_chat = create_chat_hist(self.question, [], None, self.config)
+
+        self.assertEqual(len(test_chat), 6)
+        self.assertEqual(test_chat[0],
+                         {'role': 'system', 'content': self.config.system})
+        self.assertEqual(test_chat[1],
+                         {'role': 'user', 'content': 'test_content'})
+        self.assertEqual(test_chat[2],
+                         {'role': 'assistant', 'content': 'some answer'})
+        self.assertEqual(test_chat[3],
+                         {'role': 'user', 'content': 'test_content2'})
+        self.assertEqual(test_chat[4],
+                         {'role': 'assistant', 'content': 'some answer2'})
+
+
+class TestHandleQuestion(CmmTestCase):
+
+    def setUp(self) -> None:
+        self.question = "test question"
+        self.args = argparse.Namespace(
+            tags=['tag1'],
+            extags=['extag1'],
+            output_tags=None,
+            question=[self.question],
+            source=None,
+            only_source_code=False,
+            number=3,
+            max_tokens=None,
+            temperature=None,
+            model=None,
+            match_all_tags=False,
+            with_tags=False,
+            with_file=False,
+        )
+        self.config = self.dummy_config(db='test_files')
+
+    @patch("chatmastermind.main.create_chat_hist", return_value="test_chat")
+    @patch("chatmastermind.main.print_tag_args")
+    @patch("chatmastermind.main.print_chat_hist")
+    @patch("chatmastermind.main.ai", return_value=(["answer1", "answer2", "answer3"], "test_usage"))
+    @patch("chatmastermind.utils.pp")
+    @patch("builtins.print")
+    def test_ask_cmd(self, mock_print: MagicMock, mock_pp: MagicMock, mock_ai: MagicMock,
+                     mock_print_chat_hist: MagicMock, mock_print_tag_args: MagicMock,
+                     mock_create_chat_hist: MagicMock) -> None:
+        open_mock = MagicMock()
+        with patch("chatmastermind.storage.open", open_mock):
+            ask_cmd(self.args, self.config)
+            mock_print_tag_args.assert_called_once_with(self.args.tags,
+                                                        self.args.extags,
+                                                        [])
+            mock_create_chat_hist.assert_called_once_with(self.question,
+                                                          self.args.tags,
+                                                          self.args.extags,
+                                                          self.config,
+                                                          False, False, False)
+            mock_print_chat_hist.assert_called_once_with('test_chat',
+                                                         False,
+                                                         self.args.only_source_code)
+            mock_ai.assert_called_with("test_chat",
+                                       self.config,
+                                       self.args.number)
+            expected_calls = []
+            for num, answer in enumerate(mock_ai.return_value[0], start=1):
+                title = f'-- ANSWER {num} '
+                title_end = '-' * (terminal_width() - len(title))
+                expected_calls.append(((f'{title}{title_end}',),))
+                expected_calls.append(((answer,),))
+            expected_calls.append((("-" * terminal_width(),),))
+            expected_calls.append(((f"Usage: {mock_ai.return_value[1]}",),))
+            self.assertEqual(mock_print.call_args_list, expected_calls)
+            open_expected_calls = list([mock.call(f"{num:04d}.txt", "w") for num in range(2, 5)])
+            open_mock.assert_has_calls(open_expected_calls, any_order=True)
+
+
+class TestSaveAnswers(CmmTestCase):
+    @mock.patch('builtins.open')
+    @mock.patch('chatmastermind.storage.print')
+    def test_save_answers(self, print_mock: MagicMock, open_mock: MagicMock) -> None:
+        question = "Test question?"
+        answers = ["Answer 1", "Answer 2"]
+        tags = ["tag1", "tag2"]
+        otags = ["otag1", "otag2"]
+        config = self.dummy_config(db='test_db')
+
+        with mock.patch('chatmastermind.storage.pathlib.Path.exists', return_value=True), \
+             mock.patch('chatmastermind.storage.yaml.dump'), \
+             mock.patch('io.StringIO') as stringio_mock:
+            stringio_instance = stringio_mock.return_value
+            stringio_instance.getvalue.side_effect = ["question", "answer1", "answer2"]
+            save_answers(question, answers, tags, otags, config)
+
+        open_calls = [
+            mock.call(pathlib.Path('test_db/.next'), 'r'),
+            mock.call(pathlib.Path('test_db/.next'), 'w'),
+        ]
+        open_mock.assert_has_calls(open_calls, any_order=True)
+
+
+class TestAI(CmmTestCase):
+
+    @patch("openai.ChatCompletion.create")
+    def test_ai(self, mock_create: MagicMock) -> None:
+        mock_create.return_value = {
+            'choices': [
+                {'message': {'content': 'response_text_1'}},
+                {'message': {'content': 'response_text_2'}}
+            ],
+            'usage': {'tokens': 10}
+        }
+
+        chat = [{"role": "system", "content": "hello ai"}]
+        config = self.dummy_config(db='dummy')
+        config.openai.model = "text-davinci-002"
+        config.openai.max_tokens = 150
+        config.openai.temperature = 0.5
+
+        result = ai(chat, config, 2)
+        expected_result = (['response_text_1', 'response_text_2'],
+                           {'tokens': 10})
+        self.assertEqual(result, expected_result)
+
+
+class TestCreateParser(CmmTestCase):
+    def test_create_parser(self) -> None:
+        with patch('argparse.ArgumentParser.add_subparsers') as mock_add_subparsers:
+            mock_cmdparser = Mock()
+            mock_add_subparsers.return_value = mock_cmdparser
+            parser = create_parser()
+            self.assertIsInstance(parser, argparse.ArgumentParser)
+            mock_add_subparsers.assert_called_once_with(dest='command', title='commands', description='supported commands', required=True)
+            mock_cmdparser.add_parser.assert_any_call('ask', parents=ANY, help=ANY, aliases=ANY)
+            mock_cmdparser.add_parser.assert_any_call('hist', parents=ANY, help=ANY, aliases=ANY)
+            mock_cmdparser.add_parser.assert_any_call('tag', help=ANY, aliases=ANY)
+            mock_cmdparser.add_parser.assert_any_call('config', help=ANY, aliases=ANY)
+            mock_cmdparser.add_parser.assert_any_call('print', help=ANY, aliases=ANY)
+            self.assertTrue('.config.yaml' in parser.get_default('config'))

tests/test_message.py

@@ -1,12 +1,12 @@
-import unittest
 import pathlib
 import tempfile
 from typing import cast
+from .test_main import CmmTestCase
 from chatmastermind.message import source_code, Message, MessageError, Question, Answer, AILine, ModelLine, MessageFilter, message_in
 from chatmastermind.tags import Tag, TagLine
 
 
-class SourceCodeTestCase(unittest.TestCase):
+class SourceCodeTestCase(CmmTestCase):
     def test_source_code_with_include_delims(self) -> None:
         text = """
         Some text before the code block
@@ -60,46 +60,29 @@ class SourceCodeTestCase(unittest.TestCase):
         self.assertEqual(result, expected_result)
 
 
-class QuestionTestCase(unittest.TestCase):
-    def test_question_with_header(self) -> None:
+class QuestionTestCase(CmmTestCase):
+    def test_question_with_prefix(self) -> None:
         with self.assertRaises(MessageError):
-            Question(f"{Question.txt_header}\nWhat is your name?")
+            Question("=== QUESTION === What is your name?")
 
-    def test_question_with_answer_header(self) -> None:
-        with self.assertRaises(MessageError):
-            Question(f"{Answer.txt_header}\nBob")
-
-    def test_question_with_legal_header(self) -> None:
-        """
-        If the header is just a part of a line, it's fine.
-        """
-        question = Question(f"This is a line contaning '{Question.txt_header}'\nWhat does that mean?")
-        self.assertIsInstance(question, Question)
-        self.assertEqual(question, f"This is a line contaning '{Question.txt_header}'\nWhat does that mean?")
-
-    def test_question_without_header(self) -> None:
+    def test_question_without_prefix(self) -> None:
         question = Question("What is your favorite color?")
         self.assertIsInstance(question, Question)
         self.assertEqual(question, "What is your favorite color?")
 
 
-class AnswerTestCase(unittest.TestCase):
-    def test_answer_with_header(self) -> None:
+class AnswerTestCase(CmmTestCase):
+    def test_answer_with_prefix(self) -> None:
         with self.assertRaises(MessageError):
-            Answer(f"{Answer.txt_header}\nno")
+            Answer("=== ANSWER === Yes")
 
-    def test_answer_with_legal_header(self) -> None:
-        answer = Answer(f"This is a line contaning '{Answer.txt_header}'\nIt is what it is.")
-        self.assertIsInstance(answer, Answer)
-        self.assertEqual(answer, f"This is a line contaning '{Answer.txt_header}'\nIt is what it is.")
-
-    def test_answer_without_header(self) -> None:
+    def test_answer_without_prefix(self) -> None:
         answer = Answer("No")
         self.assertIsInstance(answer, Answer)
         self.assertEqual(answer, "No")
 
 
-class MessageToFileTxtTestCase(unittest.TestCase):
+class MessageToFileTxtTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.file = tempfile.NamedTemporaryFile(delete=False, suffix='.txt')
         self.file_path = pathlib.Path(self.file.name)
@@ -160,7 +143,7 @@ This is a question.
         self.message_complete.file_path = self.file_path
 
 
-class MessageToFileYamlTestCase(unittest.TestCase):
+class MessageToFileYamlTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.file = tempfile.NamedTemporaryFile(delete=False, suffix='.yaml')
         self.file_path = pathlib.Path(self.file.name)
@@ -226,7 +209,7 @@ class MessageToFileYamlTestCase(unittest.TestCase):
         self.assertEqual(content, expected_content)
 
 
-class MessageFromFileTxtTestCase(unittest.TestCase):
+class MessageFromFileTxtTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.file = tempfile.NamedTemporaryFile(delete=False, suffix='.txt')
         self.file_path = pathlib.Path(self.file.name)
@@ -300,12 +283,6 @@ This is a question.
                                     MessageFilter(tags_or={Tag('tag1')}))
         self.assertIsNone(message)
 
-    def test_from_file_txt_empty_tags_dont_match(self) -> None:
-        message = Message.from_file(self.file_path_min,
-                                    MessageFilter(tags_or=set(),
-                                                  tags_and=set()))
-        self.assertIsNone(message)
-
     def test_from_file_txt_no_tags_match_tags_not(self) -> None:
         message = Message.from_file(self.file_path_min,
                                     MessageFilter(tags_not={Tag('tag1')}))
@@ -394,7 +371,7 @@ This is a question.
         self.assertIsNone(message)
 
 
-class MessageFromFileYamlTestCase(unittest.TestCase):
+class MessageFromFileYamlTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.file = tempfile.NamedTemporaryFile(delete=False, suffix='.yaml')
         self.file_path = pathlib.Path(self.file.name)
@@ -561,7 +538,7 @@ class MessageFromFileYamlTestCase(unittest.TestCase):
         self.assertIsNone(message)
 
 
-class TagsFromFileTestCase(unittest.TestCase):
+class TagsFromFileTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.file_txt = tempfile.NamedTemporaryFile(delete=False, suffix='.txt')
         self.file_path_txt = pathlib.Path(self.file_txt.name)
@@ -669,7 +646,7 @@ This is an answer.
         self.assertSetEqual(tags, set())
 
 
-class TagsFromDirTestCase(unittest.TestCase):
+class TagsFromDirTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.temp_dir = tempfile.TemporaryDirectory()
         self.temp_dir_no_tags = tempfile.TemporaryDirectory()
@@ -717,7 +694,7 @@ class TagsFromDirTestCase(unittest.TestCase):
         self.assertSetEqual(all_tags, set())
 
 
-class MessageIDTestCase(unittest.TestCase):
+class MessageIDTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.file = tempfile.NamedTemporaryFile(delete=False, suffix='.txt')
         self.file_path = pathlib.Path(self.file.name)
@@ -730,14 +707,14 @@ 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):
             self.message_no_file_path.msg_id()
 
 
-class MessageHashTestCase(unittest.TestCase):
+class MessageHashTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.message1 = Message(Question('This is a question.'),
                                 tags={Tag('tag1')},
@@ -761,7 +738,7 @@ class MessageHashTestCase(unittest.TestCase):
             self.assertIn(msg, msgs)
 
 
-class MessageTagsStrTestCase(unittest.TestCase):
+class MessageTagsStrTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.message = Message(Question('This is a question.'),
                                tags={Tag('tag1')},
@@ -771,7 +748,7 @@ class MessageTagsStrTestCase(unittest.TestCase):
         self.assertEqual(self.message.tags_str(), f'{TagLine.prefix} tag1')
 
 
-class MessageFilterTagsTestCase(unittest.TestCase):
+class MessageFilterTagsTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.message = Message(Question('This is a question.'),
                                tags={Tag('atag1'), Tag('btag2')},
@@ -786,7 +763,7 @@ class MessageFilterTagsTestCase(unittest.TestCase):
         self.assertSetEqual(tags_cont, {Tag('btag2')})
 
 
-class MessageInTestCase(unittest.TestCase):
+class MessageInTestCase(CmmTestCase):
     def setUp(self) -> None:
         self.message1 = Message(Question('This is a question.'),
                                 tags={Tag('atag1'), Tag('btag2')},
@@ -798,39 +775,3 @@ class MessageInTestCase(unittest.TestCase):
     def test_message_in(self) -> None:
         self.assertTrue(message_in(self.message1, [self.message1]))
         self.assertFalse(message_in(self.message1, [self.message2]))
-
-
-class MessageRenameTagsTestCase(unittest.TestCase):
-    def setUp(self) -> None:
-        self.message = Message(Question('This is a question.'),
-                               tags={Tag('atag1'), Tag('btag2')},
-                               file_path=pathlib.Path('/tmp/foo/bla'))
-
-    def test_rename_tags(self) -> None:
-        self.message.rename_tags({(Tag('atag1'), Tag('atag2')), (Tag('btag2'), Tag('btag3'))})
-        self.assertIsNotNone(self.message.tags)
-        self.assertSetEqual(self.message.tags, {Tag('atag2'), Tag('btag3')})  # type: ignore [arg-type]
-
-
-class MessageToStrTestCase(unittest.TestCase):
-    def setUp(self) -> None:
-        self.message = Message(Question('This is a question.'),
-                               Answer('This is an answer.'),
-                               tags={Tag('atag1'), Tag('btag2')},
-                               file_path=pathlib.Path('/tmp/foo/bla'))
-
-    def test_to_str(self) -> None:
-        expected_output = f"""{Question.txt_header}
-This is a question.
-{Answer.txt_header}
-This is an answer."""
-        self.assertEqual(self.message.to_str(), expected_output)
-
-    def test_to_str_with_tags_and_file(self) -> None:
-        expected_output = f"""{TagLine.prefix} atag1 btag2
-FILE: /tmp/foo/bla
-{Question.txt_header}
-This is a question.
-{Answer.txt_header}
-This is an answer."""
-        self.assertEqual(self.message.to_str(with_tags=True, with_file=True), expected_output)

tests/test_question_cmd.py

@@ -1,195 +0,0 @@
-import os
-import unittest
-import argparse
-import tempfile
-from pathlib import Path
-from unittest.mock import MagicMock
-from chatmastermind.commands.question import create_message
-from chatmastermind.message import Message, Question, Answer
-from chatmastermind.chat import ChatDB
-
-
-class TestMessageCreate(unittest.TestCase):
-    """
-    Test if messages created by the 'question' command have
-    the correct format.
-    """
-    def setUp(self) -> None:
-        # create ChatDB structure
-        self.db_path = tempfile.TemporaryDirectory()
-        self.cache_path = tempfile.TemporaryDirectory()
-        self.chat = ChatDB.from_dir(cache_path=Path(self.cache_path.name),
-                                    db_path=Path(self.db_path.name))
-        # create some messages
-        self.message_text = Message(Question("What is this?"),
-                                    Answer("It is pure text"))
-        self.message_code = Message(Question("What is this?"),
-                                    Answer("Text\n```\nIt is embedded code\n```\ntext"))
-        self.chat.db_add([self.message_text, self.message_code])
-        # create arguments mock
-        self.args = MagicMock(spec=argparse.Namespace)
-        self.args.source_text = None
-        self.args.source_code = None
-        self.args.AI = None
-        self.args.model = None
-        self.args.output_tags = None
-        # File 1 : no source code block, only text
-        self.source_file1 = tempfile.NamedTemporaryFile(delete=False)
-        self.source_file1_content = """This is just text.
-No source code.
-Nope. Go look elsewhere!"""
-        with open(self.source_file1.name, 'w') as f:
-            f.write(self.source_file1_content)
-        # File 2 : one embedded source code block
-        self.source_file2 = tempfile.NamedTemporaryFile(delete=False)
-        self.source_file2_content = """This is just text.
-```
-This is embedded source code.
-```
-And some text again."""
-        with open(self.source_file2.name, 'w') as f:
-            f.write(self.source_file2_content)
-        # File 3 : all source code
-        self.source_file3 = tempfile.NamedTemporaryFile(delete=False)
-        self.source_file3_content = """This is all source code.
-Yes, really.
-Language is called 'brainfart'."""
-        with open(self.source_file3.name, 'w') as f:
-            f.write(self.source_file3_content)
-        # File 4 : two source code blocks
-        self.source_file4 = tempfile.NamedTemporaryFile(delete=False)
-        self.source_file4_content = """This is just text.
-```
-This is embedded source code.
-```
-And some text again.
-```
-This is embedded source code.
-```
-Aaaand again some text."""
-        with open(self.source_file4.name, 'w') as f:
-            f.write(self.source_file4_content)
-
-    def tearDown(self) -> None:
-        os.remove(self.source_file1.name)
-        os.remove(self.source_file2.name)
-        os.remove(self.source_file3.name)
-
-    def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[Path]:
-        # exclude '.next'
-        return list(Path(tmp_dir.name).glob('*.[ty]*'))
-
-    def test_message_file_created(self) -> None:
-        self.args.ask = ["What is this?"]
-        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_path)
-        self.assertEqual(len(cache_dir_files), 1)
-        message = Message.from_file(cache_dir_files[0])
-        self.assertIsInstance(message, Message)
-        self.assertEqual(message.question, Question("What is this?"))  # type: ignore [union-attr]
-
-    def test_single_question(self) -> None:
-        self.args.ask = ["What is this?"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        self.assertEqual(message.question, Question("What is this?"))
-        self.assertEqual(len(message.question.source_code()), 0)
-
-    def test_multipart_question(self) -> None:
-        self.args.ask = ["What is this", "'bard' thing?", "Is it good?"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        self.assertEqual(message.question, Question("""What is this
-
-'bard' thing?
-
-Is it good?"""))
-
-    def test_single_question_with_text_only_file(self) -> None:
-        self.args.ask = ["What is this?"]
-        self.args.source_text = [f"{self.source_file1.name}"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        # file contains no source code (only text)
-        # -> don't expect any in the question
-        self.assertEqual(len(message.question.source_code()), 0)
-        self.assertEqual(message.question, Question(f"""What is this?
-
-{self.source_file1_content}"""))
-
-    def test_single_question_with_text_file_and_embedded_code(self) -> None:
-        self.args.ask = ["What is this?"]
-        self.args.source_code = [f"{self.source_file2.name}"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        # file contains 1 source code block
-        # -> expect it in the question
-        self.assertEqual(len(message.question.source_code()), 1)
-        self.assertEqual(message.question, Question("""What is this?
-
-```
-This is embedded source code.
-```
-"""))
-
-    def test_single_question_with_code_only_file(self) -> None:
-        self.args.ask = ["What is this?"]
-        self.args.source_code = [f"{self.source_file3.name}"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        # file is complete source code
-        self.assertEqual(len(message.question.source_code()), 1)
-        self.assertEqual(message.question, Question(f"""What is this?
-
-```
-{self.source_file3_content}
-```"""))
-
-    def test_single_question_with_text_file_and_multi_embedded_code(self) -> None:
-        self.args.ask = ["What is this?"]
-        self.args.source_code = [f"{self.source_file4.name}"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        # file contains 2 source code blocks
-        # -> expect them in the question
-        self.assertEqual(len(message.question.source_code()), 2)
-        self.assertEqual(message.question, Question("""What is this?
-
-```
-This is embedded source code.
-```
-
-
-```
-This is embedded source code.
-```
-"""))
-
-    def test_single_question_with_text_only_message(self) -> None:
-        self.args.ask = ["What is this?"]
-        self.args.source_text = [f"{self.chat.messages[0].file_path}"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        # file contains no source code (only text)
-        # -> don't expect any in the question
-        self.assertEqual(len(message.question.source_code()), 0)
-        self.assertEqual(message.question, Question(f"""What is this?
-
-{self.message_text.answer}"""))
-
-    def test_single_question_with_message_and_embedded_code(self) -> None:
-        self.args.ask = ["What is this?"]
-        self.args.source_code = [f"{self.chat.messages[1].file_path}"]
-        message = create_message(self.chat, self.args)
-        self.assertIsInstance(message, Message)
-        # answer contains 1 source code block
-        # -> expect it in the question
-        self.assertEqual(len(message.question.source_code()), 1)
-        self.assertEqual(message.question, Question("""What is this?
-
-```
-It is embedded code
-```
-"""))

tests/test_tags.py

@@ -1,8 +1,8 @@
-import unittest
+from .test_main import CmmTestCase
 from chatmastermind.tags import Tag, TagLine, TagError
 
 
-class TestTag(unittest.TestCase):
+class TestTag(CmmTestCase):
     def test_valid_tag(self) -> None:
         tag = Tag('mytag')
         self.assertEqual(tag, 'mytag')
@@ -18,7 +18,7 @@ class TestTag(unittest.TestCase):
         self.assertEqual(Tag.alternative_separators, [','])
 
 
-class TestTagLine(unittest.TestCase):
+class TestTagLine(CmmTestCase):
     def test_valid_tagline(self) -> None:
         tagline = TagLine('TAGS: tag1 tag2')
         self.assertEqual(tagline, 'TAGS: tag1 tag2')
@@ -144,20 +144,3 @@ class TestTagLine(unittest.TestCase):
         # Test case 9: 'tags_or' and 'tags_and' are None, match all tags except excluded tags
         tags_not = {Tag('tag2')}
         self.assertFalse(tagline.match_tags(None, None, tags_not))
-
-        # Test case 10: 'tags_or' and 'tags_and' are empty, match no tags
-        self.assertFalse(tagline.match_tags(set(), set(), None))
-
-        # Test case 11: 'tags_or' is empty, match no tags
-        self.assertFalse(tagline.match_tags(set(), None, None))
-
-        # Test case 12: 'tags_and' is empty, match no tags
-        self.assertFalse(tagline.match_tags(None, set(), None))
-
-        # Test case 13: 'tags_or' is empty, match 'tags_and'
-        tags_and = {Tag('tag1'), Tag('tag2')}
-        self.assertTrue(tagline.match_tags(None, tags_and, None))
-
-        # Test case 14: 'tags_and' is empty, match 'tags_or'
-        tags_or = {Tag('tag1'), Tag('tag2')}
-        self.assertTrue(tagline.match_tags(tags_or, None, None))