From 80a1457dd152d64da0e579f1d9cf1211a9766c95 Mon Sep 17 00:00:00 2001 From: juk0de Date: Mon, 18 Sep 2023 14:34:10 +0200 Subject: [PATCH 1/9] configuration: the cache folder can now be specified in the configuration file --- chatmastermind/commands/hist.py | 2 +- chatmastermind/commands/question.py | 2 +- chatmastermind/commands/tags.py | 2 +- chatmastermind/configuration.py | 2 ++ tests/test_configuration.py | 7 +++++++ 5 files changed, 12 insertions(+), 3 deletions(-) diff --git a/chatmastermind/commands/hist.py b/chatmastermind/commands/hist.py index 88ed3be..5b14bd2 100644 --- a/chatmastermind/commands/hist.py +++ b/chatmastermind/commands/hist.py @@ -15,7 +15,7 @@ def hist_cmd(args: argparse.Namespace, config: Config) -> None: tags_not=args.exclude_tags, question_contains=args.question, answer_contains=args.answer) - chat = ChatDB.from_dir(Path('.'), + chat = ChatDB.from_dir(Path(config.cache), Path(config.db), mfilter=mfilter) chat.print(args.source_code_only, diff --git a/chatmastermind/commands/question.py b/chatmastermind/commands/question.py index 78a6c4e..faba681 100644 --- a/chatmastermind/commands/question.py +++ b/chatmastermind/commands/question.py @@ -84,7 +84,7 @@ def question_cmd(args: argparse.Namespace, config: Config) -> None: mfilter = MessageFilter(tags_or=args.or_tags if args.or_tags is not None else set(), tags_and=args.and_tags if args.and_tags is not None else set(), tags_not=args.exclude_tags if args.exclude_tags is not None else set()) - chat = ChatDB.from_dir(cache_path=Path('.'), + chat = ChatDB.from_dir(cache_path=Path(config.cache), db_path=Path(config.db), mfilter=mfilter) # if it's a new question, create and store it immediately diff --git a/chatmastermind/commands/tags.py b/chatmastermind/commands/tags.py index 71574ff..61af13d 100644 --- a/chatmastermind/commands/tags.py +++ b/chatmastermind/commands/tags.py @@ -8,7 +8,7 @@ def tags_cmd(args: argparse.Namespace, config: Config) -> None: """ Handler for the 'tags' command. """ - chat = ChatDB.from_dir(cache_path=Path('.'), + chat = ChatDB.from_dir(cache_path=Path(config.cache), db_path=Path(config.db)) if args.list: tags_freq = chat.msg_tags_frequency(args.prefix, args.contain) diff --git a/chatmastermind/configuration.py b/chatmastermind/configuration.py index d1f9601..7dfa78a 100644 --- a/chatmastermind/configuration.py +++ b/chatmastermind/configuration.py @@ -116,6 +116,7 @@ class Config: """ # all members have default values, so we can easily create # a default configuration + cache: str = '.' db: str = './db/' ais: dict[str, AIConfig] = field(default_factory=create_default_ai_configs) @@ -132,6 +133,7 @@ class Config: ai_conf = ai_config_instance(conf['name'], conf) ais[ID] = ai_conf return cls( + cache=str(source['cache']) if 'cache' in source else '.', db=str(source['db']), ais=ais ) diff --git a/tests/test_configuration.py b/tests/test_configuration.py index ba8a5aa..3e866f2 100644 --- a/tests/test_configuration.py +++ b/tests/test_configuration.py @@ -57,6 +57,7 @@ class TestConfig(unittest.TestCase): def test_from_dict_should_create_config_from_dict(self) -> None: source_dict = { + 'cache': '.', 'db': './test_db/', 'ais': { 'myopenai': { @@ -73,6 +74,7 @@ class TestConfig(unittest.TestCase): } } config = Config.from_dict(source_dict) + self.assertEqual(config.cache, '.') self.assertEqual(config.db, './test_db/') self.assertEqual(len(config.ais), 1) self.assertEqual(config.ais['myopenai'].name, 'openai') @@ -89,6 +91,7 @@ class TestConfig(unittest.TestCase): def test_from_file_should_load_config_from_file(self) -> None: source_dict = { + 'cache': './test_cache/', 'db': './test_db/', 'ais': { 'default': { @@ -108,6 +111,7 @@ class TestConfig(unittest.TestCase): yaml.dump(source_dict, f) config = Config.from_file(self.test_file.name) self.assertIsInstance(config, Config) + self.assertEqual(config.cache, './test_cache/') self.assertEqual(config.db, './test_db/') self.assertEqual(len(config.ais), 1) self.assertIsInstance(config.ais['default'], AIConfig) @@ -115,6 +119,7 @@ class TestConfig(unittest.TestCase): def test_to_file_should_save_config_to_file(self) -> None: config = Config( + cache='./test_cache/', db='./test_db/', ais={ 'myopenai': OpenAIConfig( @@ -133,12 +138,14 @@ class TestConfig(unittest.TestCase): config.to_file(Path(self.test_file.name)) with open(self.test_file.name, 'r') as f: saved_config = yaml.load(f, Loader=yaml.FullLoader) + self.assertEqual(saved_config['cache'], './test_cache/') self.assertEqual(saved_config['db'], './test_db/') self.assertEqual(len(saved_config['ais']), 1) self.assertEqual(saved_config['ais']['myopenai']['system'], 'Custom system') def test_from_file_error_unknown_ai(self) -> None: source_dict = { + 'cache': './test_cache/', 'db': './test_db/', 'ais': { 'default': { From 29a20bd2d825b52b268fc441545da8d7a1320f17 Mon Sep 17 00:00:00 2001 From: juk0de Date: Tue, 19 Sep 2023 09:36:23 +0200 Subject: [PATCH 2/9] message: added 'equals()' function and improved robustness and debugging --- chatmastermind/message.py | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/chatmastermind/message.py b/chatmastermind/message.py index 498de88..1fb60b3 100644 --- a/chatmastermind/message.py +++ b/chatmastermind/message.py @@ -222,12 +222,36 @@ class Message(): ai_yaml_key: ClassVar[str] = 'ai' model_yaml_key: ClassVar[str] = 'model' + def __post_init__(self) -> None: + # convert some types that are often set wrong + if self.tags is not None and not isinstance(self.tags, set): + self.tags = set(self.tags) + if self.file_path is not None and not isinstance(self.file_path, pathlib.Path): + self.file_path = pathlib.Path(self.file_path) + def __hash__(self) -> int: """ The hash value is computed based on immutable members. """ return hash((self.question, self.answer)) + def equals(self, other: MessageInst, tags: bool = True, ai: bool = True, + model: bool = True, file_path: bool = True, verbose: bool = False) -> bool: + """ + Compare this message with another one, including the metadata. + Return True if everything is identical, False otherwise. + """ + equal: bool = ((not tags or (self.tags == other.tags)) + and (not ai or (self.ai == other.ai)) # noqa: W503 + and (not model or (self.model == other.model)) # noqa: W503 + and (not file_path or (self.file_path == other.file_path)) # noqa: W503 + and (self == other)) # noqa: W503 + if not equal and verbose: + print("Messages not equal:") + print(self) + print(other) + return equal + @classmethod def from_dict(cls: Type[MessageInst], data: dict[str, Any]) -> MessageInst: """ @@ -418,9 +442,6 @@ class Message(): output.append(self.answer) return '\n'.join(output) - def __str__(self) -> str: - return self.to_str(True, True, False) - def to_file(self, file_path: Optional[pathlib.Path]=None) -> None: # noqa: 11 """ Write a Message to the given file. Type is determined based on the suffix. From 59eb45a3ca3b59be5d9f1d0f5563cd4dc62954f5 Mon Sep 17 00:00:00 2001 From: juk0de Date: Tue, 19 Sep 2023 09:48:12 +0200 Subject: [PATCH 3/9] chat: improved message equality checks --- tests/test_chat.py | 83 ++++++++++++++++++++++++++-------------------- 1 file changed, 47 insertions(+), 36 deletions(-) diff --git a/tests/test_chat.py b/tests/test_chat.py index 4558e4d..a69f92c 100644 --- a/tests/test_chat.py +++ b/tests/test_chat.py @@ -10,7 +10,18 @@ from chatmastermind.message import Message, Question, Answer, Tag, MessageFilter from chatmastermind.chat import Chat, ChatDB, ChatError -class TestChat(unittest.TestCase): +class TestChatBase(unittest.TestCase): + def assert_messages_equal(self, msg1: list[Message], msg2: list[Message]) -> None: + """ + Compare messages using more than just Question and Answer. + """ + self.assertEqual(len(msg1), len(msg2)) + for m1, m2 in zip(msg1, msg2): + # exclude the file_path, compare only Q, A and metadata + self.assertTrue(m1.equals(m2, file_path=False, verbose=True)) + + +class TestChat(TestChatBase): def setUp(self) -> None: self.chat = Chat([]) self.message1 = Message(Question('Question 1'), @@ -26,24 +37,24 @@ class TestChat(unittest.TestCase): 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.assert_messages_equal(self.chat.messages, [self.message1, self.message1]) self.chat.msg_unique_id() - self.assertSequenceEqual(self.chat.messages, [self.message1]) + self.assert_messages_equal(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]) + self.assert_messages_equal(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.assert_messages_equal(self.chat.messages, [self.message1, self.message1]) self.chat.msg_unique_content() - self.assertSequenceEqual(self.chat.messages, [self.message1]) + self.assert_messages_equal(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]) + self.assert_messages_equal(self.chat.messages, [self.message1, self.message2]) def test_filter(self) -> None: self.chat.msg_add([self.message1, self.message2]) @@ -150,7 +161,7 @@ Answer 2 self.assertEqual(mock_stdout.getvalue(), expected_output) -class TestChatDB(unittest.TestCase): +class TestChatDB(TestChatBase): def setUp(self) -> None: self.db_path = tempfile.TemporaryDirectory() self.cache_path = tempfile.TemporaryDirectory() @@ -569,7 +580,7 @@ class TestChatDB(unittest.TestCase): 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) + self.assert_messages_equal(result, expected_result) def test_msg_latest(self) -> None: chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name), @@ -595,47 +606,47 @@ class TestChatDB(unittest.TestCase): 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'), []) + self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='cache'), []) # add a new message, but only to the internal list new_message = Message(Question("What?")) all_messages_mem = all_messages + [new_message] chat_db.msg_add([new_message]) - self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages_mem) - self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages_mem) + self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages_mem) + self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages_mem) # the nr. of messages on disk did not change -> expect old result - self.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'), []) + self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='cache'), []) # test with MessageFilter - self.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]) + self.assert_messages_equal(chat_db.msg_gather(loc='all', mfilter=MessageFilter(tags_or={Tag('tag1')})), + [self.message1]) + self.assert_messages_equal(chat_db.msg_gather(loc='disk', mfilter=MessageFilter(tags_or={Tag('tag2')})), + [self.message2]) + self.assert_messages_equal(chat_db.msg_gather(loc='cache', mfilter=MessageFilter(tags_or={Tag('tag3')})), + []) + self.assert_messages_equal(chat_db.msg_gather(loc='mem', mfilter=MessageFilter(question_contains="What")), + [new_message]) def test_msg_move_and_gather(self) -> None: chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name), pathlib.Path(self.db_path.name)) all_messages = [self.message1, self.message2, self.message3, self.message4] - self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages) - self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), []) + self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='cache'), []) # move first message to the cache chat_db.cache_move(self.message1) - self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [self.message1]) + self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [self.message1]) self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.cache_path.name)) # type: ignore [union-attr] - self.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) + self.assert_messages_equal(chat_db.msg_gather(loc='db'), [self.message2, self.message3, self.message4]) + self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages) # now move first message back to the DB chat_db.db_move(self.message1) - self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), []) + self.assert_messages_equal(chat_db.msg_gather(loc='cache'), []) self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.db_path.name)) # type: ignore [union-attr] - self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages) + self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages) From 561003aabe332a28a56d321dbd5f130ef6ba75ae Mon Sep 17 00:00:00 2001 From: juk0de Date: Thu, 14 Sep 2023 08:32:01 +0200 Subject: [PATCH 4/9] question_cmd: implemented repeating of the latest message --- chatmastermind/commands/question.py | 75 ++++++++++++++++++++--------- chatmastermind/message.py | 3 ++ 2 files changed, 55 insertions(+), 23 deletions(-) diff --git a/chatmastermind/commands/question.py b/chatmastermind/commands/question.py index faba681..37b62c4 100644 --- a/chatmastermind/commands/question.py +++ b/chatmastermind/commands/question.py @@ -1,3 +1,4 @@ +import sys import argparse from pathlib import Path from itertools import zip_longest @@ -51,7 +52,7 @@ def add_file_as_code(question_parts: list[str], file: str) -> None: def create_message(chat: ChatDB, args: argparse.Namespace) -> Message: """ - Creates a new message from the given arguments and writes it + Create a new message from the given arguments and write it to the cache directory. """ question_parts = [] @@ -70,13 +71,40 @@ def create_message(chat: ChatDB, args: argparse.Namespace) -> Message: full_question = '\n\n'.join(question_parts) message = Message(question=Question(full_question), - tags=args.output_tags, # FIXME + tags=args.output_tags, ai=args.AI, model=args.model) - chat.cache_add([message]) + # only write the new message to the cache, + # don't add it to the internal list + chat.cache_write([message]) return message +def make_request(ai: AI, chat: ChatDB, message: Message, args: argparse.Namespace) -> None: + """ + Make an AI request with the given AI, chat history, message and arguments. + Write the response(s) to the cache directory, without appending it to the + given chat history. Then print the response(s). + """ + # print history and message question before making the request + ai.print() + chat.print(paged=False) + print(message.to_str()) + response: AIResponse = ai.request(message, + chat, + args.num_answers, + args.output_tags) + # only write the response messages to the cache, + # don't add them to the internal list + chat.cache_write(response.messages) + for idx, msg in enumerate(response.messages): + print(f"=== ANSWER {idx+1} ===") + print(msg.answer) + if response.tokens: + print("===============") + print(response.tokens) + + def question_cmd(args: argparse.Namespace, config: Config) -> None: """ Handler for the 'question' command. @@ -95,28 +123,29 @@ def question_cmd(args: argparse.Namespace, config: Config) -> None: # create the correct AI instance ai: AI = create_ai(args, config) + + # === ASK === 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) + make_request(ai, chat, message, args) + # === REPEAT === 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 + lmessage = chat.msg_latest(loc='cache') + if lmessage is None: + print("No message found to repeat!") + sys.exit(1) + else: + print(f"Repeating message '{lmessage.msg_id()}':") + # overwrite the latest message if requested or empty + if lmessage.answer is None or args.overwrite is True: + lmessage.clear_answer() + make_request(ai, chat, lmessage, args) + # otherwise create a new one + else: + args.ask = [lmessage.question] + message = create_message(chat, args) + make_request(ai, chat, message, args) + + # === PROCESS === elif args.process is not None: # TODO: process either all questions without an # answer or the one(s) given in 'args.process' diff --git a/chatmastermind/message.py b/chatmastermind/message.py index 1fb60b3..443455e 100644 --- a/chatmastermind/message.py +++ b/chatmastermind/message.py @@ -561,6 +561,9 @@ class Message(): if self.tags: self.tags = rename_tags(self.tags, tags_rename) + def clear_answer(self) -> None: + self.answer = None + def msg_id(self) -> str: """ Returns an ID that is unique throughout all messages in the same (DB) directory. From 3ad4b96b8f2eb472372cd4c4481b6fffcb6171b3 Mon Sep 17 00:00:00 2001 From: juk0de Date: Mon, 18 Sep 2023 09:57:19 +0200 Subject: [PATCH 5/9] test_question_cmd: added testclass for the 'question_cmd()' function --- tests/test_question_cmd.py | 226 +++++++++++++++++++++++++++++++++++-- 1 file changed, 216 insertions(+), 10 deletions(-) diff --git a/tests/test_question_cmd.py b/tests/test_question_cmd.py index 1c6c958..b809567 100644 --- a/tests/test_question_cmd.py +++ b/tests/test_question_cmd.py @@ -3,23 +3,39 @@ import unittest import argparse import tempfile from pathlib import Path -from unittest.mock import MagicMock -from chatmastermind.commands.question import create_message +from unittest import mock +from unittest.mock import MagicMock, call, ANY +from typing import Optional +from chatmastermind.configuration import Config +from chatmastermind.commands.question import create_message, question_cmd +from chatmastermind.tags import Tag from chatmastermind.message import Message, Question, Answer -from chatmastermind.chat import ChatDB +from chatmastermind.chat import Chat, ChatDB +from chatmastermind.ai import AI, AIResponse, Tokens, AIError -class TestMessageCreate(unittest.TestCase): +class TestQuestionCmdBase(unittest.TestCase): + def assert_messages_equal(self, msg1: list[Message], msg2: list[Message]) -> None: + """ + Compare messages using more than just Question and Answer. + """ + self.assertEqual(len(msg1), len(msg2)) + for m1, m2 in zip(msg1, msg2): + # exclude the file_path, compare only Q, A and metadata + self.assertTrue(m1.equals(m2, file_path=False, verbose=True)) + + +class TestMessageCreate(TestQuestionCmdBase): """ Test if messages created by the 'question' command have the correct format. """ def setUp(self) -> None: # create ChatDB structure - self.db_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)) + self.db_dir = tempfile.TemporaryDirectory() + self.cache_dir = tempfile.TemporaryDirectory() + self.chat = ChatDB.from_dir(cache_path=Path(self.cache_dir.name), + db_path=Path(self.db_dir.name)) # create some messages self.message_text = Message(Question("What is this?"), Answer("It is pure text")) @@ -74,6 +90,7 @@ Aaaand again some text.""" os.remove(self.source_file1.name) os.remove(self.source_file2.name) os.remove(self.source_file3.name) + os.remove(self.source_file4.name) def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[Path]: # exclude '.next' @@ -81,10 +98,10 @@ Aaaand again some text.""" def test_message_file_created(self) -> None: self.args.ask = ["What is this?"] - cache_dir_files = self.message_list(self.cache_path) + cache_dir_files = self.message_list(self.cache_dir) self.assertEqual(len(cache_dir_files), 0) create_message(self.chat, self.args) - cache_dir_files = self.message_list(self.cache_path) + cache_dir_files = self.message_list(self.cache_dir) self.assertEqual(len(cache_dir_files), 1) message = Message.from_file(cache_dir_files[0]) self.assertIsInstance(message, Message) @@ -193,3 +210,192 @@ This is embedded source code. It is embedded code ``` """)) + + +class TestQuestionCmd(TestQuestionCmdBase): + + def setUp(self) -> None: + # create DB and cache + self.db_dir = tempfile.TemporaryDirectory() + self.cache_dir = tempfile.TemporaryDirectory() + # create configuration + self.config = Config() + self.config.cache = self.cache_dir.name + self.config.db = self.db_dir.name + # create a mock argparse.Namespace + self.args = argparse.Namespace( + ask=['What is the meaning of life?'], + num_answers=1, + output_tags=['science'], + AI='openai', + model='gpt-3.5-turbo', + or_tags=None, + and_tags=None, + exclude_tags=None, + source_text=None, + source_code=None, + create=None, + repeat=None, + process=None, + overwrite=None + ) + # create a mock AI instance + self.ai = MagicMock(spec=AI) + self.ai.request.side_effect = self.mock_request + + def input_message(self, args: argparse.Namespace) -> Message: + """ + Create the expected input message for a question using the + given arguments. + """ + # NOTE: we only use the first question from the "ask" list + # -> message creation using "question.create_message()" is + # tested above + # the answer is always empty for the input message + return Message(Question(args.ask[0]), + tags=args.output_tags, + ai=args.AI, + model=args.model) + + def mock_request(self, + question: Message, + chat: Chat, + num_answers: int = 1, + otags: Optional[set[Tag]] = None) -> AIResponse: + """ + Mock the 'ai.request()' function + """ + question.answer = Answer("Answer 0") + question.tags = set(otags) if otags else None + question.ai = 'FakeAI' + question.model = 'FakeModel' + answers: list[Message] = [question] + for n in range(1, num_answers): + answers.append(Message(question=question.question, + answer=Answer(f"Answer {n}"), + tags=otags, + ai='FakeAI', + model='FakeModel')) + return AIResponse(answers, Tokens(10, 10, 20)) + + def message_list(self, tmp_dir: tempfile.TemporaryDirectory) -> list[Path]: + # exclude '.next' + return sorted([f for f in Path(tmp_dir.name).glob('*.[ty]*')]) + + @mock.patch('chatmastermind.commands.question.create_ai') + def test_ask_single_answer(self, mock_create_ai: MagicMock) -> None: + """ + Test single answer with no errors + """ + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + expected_responses = self.mock_request(expected_question, + Chat([]), + self.args.num_answers, + self.args.output_tags).messages + + # execute the command + question_cmd(self.args, self.config) + + # check for correct request call + self.ai.request.assert_called_once_with(expected_question, + ANY, + self.args.num_answers, + self.args.output_tags) + # check for the expected message files + chat = ChatDB.from_dir(Path(self.cache_dir.name), + Path(self.db_dir.name)) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, expected_responses) + + @mock.patch('chatmastermind.commands.question.ChatDB.from_dir') + @mock.patch('chatmastermind.commands.question.create_ai') + def test_ask_single_answer_mocked(self, mock_create_ai: MagicMock, mock_from_dir: MagicMock) -> None: + """ + Test single answer with no errors (mocked ChatDB version) + """ + chat = MagicMock(spec=ChatDB) + mock_from_dir.return_value = chat + + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + expected_responses = self.mock_request(expected_question, + Chat([]), + self.args.num_answers, + self.args.output_tags).messages + + # execute the command + question_cmd(self.args, self.config) + + # check for correct request call + self.ai.request.assert_called_once_with(expected_question, + chat, + self.args.num_answers, + self.args.output_tags) + + # check for the correct ChatDB calls: + # - initial question has been written (prior to the actual request) + # - responses have been written (after the request) + chat.cache_write.assert_has_calls([call([expected_question]), + call(expected_responses)], + any_order=False) + + # check that the messages have not been added to the internal message list + chat.cache_add.assert_not_called() + + @mock.patch('chatmastermind.commands.question.create_ai') + def test_ask_with_error(self, mock_create_ai: MagicMock) -> None: + """ + Provoke an error during the AI request and verify that the question + has been correctly stored in the cache. + """ + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + self.ai.request.side_effect = AIError + + # execute the command + with self.assertRaises(AIError): + question_cmd(self.args, self.config) + + # check for correct request call + self.ai.request.assert_called_once_with(expected_question, + ANY, + self.args.num_answers, + self.args.output_tags) + # check for the expected message files + chat = ChatDB.from_dir(Path(self.cache_dir.name), + Path(self.db_dir.name)) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, [expected_question]) + + @mock.patch('chatmastermind.commands.question.create_ai') + def test_repeat_single_question(self, mock_create_ai: MagicMock) -> None: + """ + Repeat a single question + """ + # 1. ask a question + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + expected_responses = self.mock_request(expected_question, + Chat([]), + self.args.num_answers, + self.args.output_tags).messages + question_cmd(self.args, self.config) + chat = ChatDB.from_dir(Path(self.cache_dir.name), + Path(self.db_dir.name)) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, expected_responses) + + # 2. repeat the last question (without overwriting) + # -> expect two identical messages (except for the file_path) + self.args.ask = None + self.args.repeat = [] + self.args.overwrite = False + expected_responses += expected_responses + question_cmd(self.args, self.config) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 2) + self.assert_messages_equal(cached_msg, expected_responses) From 7dd83428fbbdb46f06b6377b1361d99815c181f0 Mon Sep 17 00:00:00 2001 From: juk0de Date: Tue, 19 Sep 2023 15:19:41 +0200 Subject: [PATCH 6/9] test_question_cmd: added more testcases for '--repeat' --- tests/test_question_cmd.py | 118 ++++++++++++++++++++++++++++++++++++- 1 file changed, 115 insertions(+), 3 deletions(-) diff --git a/tests/test_question_cmd.py b/tests/test_question_cmd.py index b809567..89c72c7 100644 --- a/tests/test_question_cmd.py +++ b/tests/test_question_cmd.py @@ -285,7 +285,7 @@ class TestQuestionCmd(TestQuestionCmdBase): @mock.patch('chatmastermind.commands.question.create_ai') def test_ask_single_answer(self, mock_create_ai: MagicMock) -> None: """ - Test single answer with no errors + Test single answer with no errors. """ mock_create_ai.return_value = self.ai expected_question = self.input_message(self.args) @@ -313,7 +313,7 @@ class TestQuestionCmd(TestQuestionCmdBase): @mock.patch('chatmastermind.commands.question.create_ai') def test_ask_single_answer_mocked(self, mock_create_ai: MagicMock, mock_from_dir: MagicMock) -> None: """ - Test single answer with no errors (mocked ChatDB version) + Test single answer with no errors (mocked ChatDB version). """ chat = MagicMock(spec=ChatDB) mock_from_dir.return_value = chat @@ -373,7 +373,7 @@ class TestQuestionCmd(TestQuestionCmdBase): @mock.patch('chatmastermind.commands.question.create_ai') def test_repeat_single_question(self, mock_create_ai: MagicMock) -> None: """ - Repeat a single question + Repeat a single question. """ # 1. ask a question mock_create_ai.return_value = self.ai @@ -399,3 +399,115 @@ class TestQuestionCmd(TestQuestionCmdBase): cached_msg = chat.msg_gather(loc='cache') self.assertEqual(len(self.message_list(self.cache_dir)), 2) self.assert_messages_equal(cached_msg, expected_responses) + + @mock.patch('chatmastermind.commands.question.create_ai') + def test_repeat_single_question_overwrite(self, mock_create_ai: MagicMock) -> None: + """ + Repeat a single question and overwrite the old one. + """ + # 1. ask a question + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + expected_responses = self.mock_request(expected_question, + Chat([]), + self.args.num_answers, + self.args.output_tags).messages + question_cmd(self.args, self.config) + chat = ChatDB.from_dir(Path(self.cache_dir.name), + Path(self.db_dir.name)) + cached_msg = chat.msg_gather(loc='cache') + assert cached_msg[0].file_path + cached_msg_file_id = cached_msg[0].file_path.stem + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, expected_responses) + + # 2. repeat the last question (WITH overwriting) + # -> expect a single message afterwards + self.args.ask = None + self.args.repeat = [] + self.args.overwrite = True + question_cmd(self.args, self.config) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, expected_responses) + # also check that the file ID has not been changed + assert cached_msg[0].file_path + self.assertEqual(cached_msg_file_id, cached_msg[0].file_path.stem) + + @mock.patch('chatmastermind.commands.question.create_ai') + def test_repeat_single_question_after_error(self, mock_create_ai: MagicMock) -> None: + """ + Repeat a single question after an error. + """ + # 1. ask a question and provoke an error + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + self.ai.request.side_effect = AIError + with self.assertRaises(AIError): + question_cmd(self.args, self.config) + chat = ChatDB.from_dir(Path(self.cache_dir.name), + Path(self.db_dir.name)) + cached_msg = chat.msg_gather(loc='cache') + assert cached_msg[0].file_path + cached_msg_file_id = cached_msg[0].file_path.stem + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, [expected_question]) + + # 2. repeat the last question (without overwriting) + # -> expect a single message because if the original has + # no answer, it should be overwritten by default + self.args.ask = None + self.args.repeat = [] + self.args.overwrite = False + self.ai.request.side_effect = self.mock_request + expected_responses = self.mock_request(expected_question, + Chat([]), + self.args.num_answers, + self.args.output_tags).messages + question_cmd(self.args, self.config) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, expected_responses) + # also check that the file ID has not been changed + assert cached_msg[0].file_path + self.assertEqual(cached_msg_file_id, cached_msg[0].file_path.stem) + + @mock.patch('chatmastermind.commands.question.create_ai') + def test_repeat_single_question_new_args(self, mock_create_ai: MagicMock) -> None: + """ + Repeat a single question with new arguments. + """ + # 1. ask a question + mock_create_ai.return_value = self.ai + expected_question = self.input_message(self.args) + expected_responses = self.mock_request(expected_question, + Chat([]), + self.args.num_answers, + self.args.output_tags).messages + question_cmd(self.args, self.config) + chat = ChatDB.from_dir(Path(self.cache_dir.name), + Path(self.db_dir.name)) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 1) + self.assert_messages_equal(cached_msg, expected_responses) + + # 2. repeat the last question with new arguments (without overwriting) + # -> expect two messages with identical question and answer, but different metadata + self.args.ask = None + self.args.repeat = [] + self.args.overwrite = False + self.args.output_tags = ['newtag'] + self.args.AI = 'newai' + self.args.model = 'newmodel' + new_expected_question = Message(question=Question(expected_question.question), + tags=set(self.args.output_tags), + ai=self.args.AI, + model=self.args.model) + expected_responses += self.mock_request(new_expected_question, + Chat([]), + self.args.num_answers, + set(self.args.output_tags)).messages + question_cmd(self.args, self.config) + cached_msg = chat.msg_gather(loc='cache') + self.assertEqual(len(self.message_list(self.cache_dir)), 2) + self.assert_messages_equal(cached_msg, expected_responses) From c43bafe47a9330cd0c91ae8fe404f71724851793 Mon Sep 17 00:00:00 2001 From: juk0de Date: Wed, 20 Sep 2023 08:48:59 +0200 Subject: [PATCH 7/9] main: improved metavar names and descriptions --- chatmastermind/main.py | 39 ++++++++++++++++++++------------------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/chatmastermind/main.py b/chatmastermind/main.py index fcd1b2f..418dafc 100755 --- a/chatmastermind/main.py +++ b/chatmastermind/main.py @@ -44,13 +44,13 @@ def create_parser() -> argparse.ArgumentParser: help='List of tags to exclude', metavar='XTAGS') etag_arg.completer = tags_completer # type: ignore otag_arg = tag_parser.add_argument('-o', '--output-tags', nargs='+', - help='List of output tags (default: use input tags)', metavar='OUTTAGS') + help='List of output tags (default: use input tags)', metavar='OUTAGS') 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('-A', '--AI', help='AI ID to use', metavar='AI_ID') + ai_parser.add_argument('-M', '--model', help='Model to use', metavar='MODEL') ai_parser.add_argument('-n', '--num-answers', help='Number of answers to request', type=int, default=1) ai_parser.add_argument('-m', '--max-tokens', help='Max. nr. of tokens', type=int) ai_parser.add_argument('-T', '--temperature', help='Temperature value', type=float) @@ -61,14 +61,15 @@ def create_parser() -> argparse.ArgumentParser: aliases=['q']) question_cmd_parser.set_defaults(func=question_cmd) question_group = question_cmd_parser.add_mutually_exclusive_group(required=True) - question_group.add_argument('-a', '--ask', nargs='+', help='Ask a question') - 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_group.add_argument('-a', '--ask', nargs='+', help='Ask a question', metavar='QUESTION') + question_group.add_argument('-c', '--create', nargs='+', help='Create a question', metavar='QUESTION') + question_group.add_argument('-r', '--repeat', nargs='*', help='Repeat a question', metavar='MESSAGE') + question_group.add_argument('-p', '--process', nargs='*', help='Process existing questions', metavar='MESSAGE') question_cmd_parser.add_argument('-O', '--overwrite', help='Overwrite existing messages when repeating them', action='store_true') - question_cmd_parser.add_argument('-s', '--source-text', nargs='+', help='Add content of a file to the query') - question_cmd_parser.add_argument('-S', '--source-code', nargs='+', help='Add source code file content to the chat history') + question_cmd_parser.add_argument('-s', '--source-text', nargs='+', help='Add content of a file to the query', metavar='FILE') + question_cmd_parser.add_argument('-S', '--source-code', nargs='+', help='Add source code file content to the chat history', + metavar='FILE') # 'hist' command parser hist_cmd_parser = cmdparser.add_parser('hist', parents=[tag_parser], @@ -79,10 +80,10 @@ def create_parser() -> argparse.ArgumentParser: action='store_true') hist_cmd_parser.add_argument('-W', '--with-files', help="Print chat history with filenames.", action='store_true') - hist_cmd_parser.add_argument('-S', '--source-code-only', help='Print only source code', + hist_cmd_parser.add_argument('-S', '--source-code-only', help='Only print embedded 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') + hist_cmd_parser.add_argument('-A', '--answer', help='Search for answer substring', metavar='SUBSTRING') + hist_cmd_parser.add_argument('-Q', '--question', help='Search for question substring', metavar='SUBSTRING') # 'tags' command parser tags_cmd_parser = cmdparser.add_parser('tags', @@ -92,8 +93,8 @@ def create_parser() -> argparse.ArgumentParser: tags_group = tags_cmd_parser.add_mutually_exclusive_group(required=True) tags_group.add_argument('-l', '--list', help="List all tags and their frequency", action='store_true') - tags_cmd_parser.add_argument('-p', '--prefix', help="Filter tags by prefix") - tags_cmd_parser.add_argument('-c', '--contain', help="Filter tags by contained substring") + tags_cmd_parser.add_argument('-p', '--prefix', help="Filter tags by prefix", metavar='PREFIX') + tags_cmd_parser.add_argument('-c', '--contain', help="Filter tags by contained substring", metavar='SUBSTRING') # 'config' command parser config_cmd_parser = cmdparser.add_parser('config', @@ -106,18 +107,18 @@ def create_parser() -> argparse.ArgumentParser: action='store_true') config_group.add_argument('-m', '--print-model', help="Print the currently configured model", action='store_true') - config_group.add_argument('-c', '--create', help="Create config with default settings in the given file") + config_group.add_argument('-c', '--create', help="Create config with default settings in the given file", metavar='FILE') # 'print' command parser print_cmd_parser = cmdparser.add_parser('print', help="Print message files.", aliases=['p']) print_cmd_parser.set_defaults(func=print_cmd) - print_cmd_parser.add_argument('-f', '--file', help='File to print', required=True) + print_cmd_parser.add_argument('-f', '--file', help='Print given message file', required=True, metavar='FILE') 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_modes.add_argument('-q', '--question', help='Only print the question', action='store_true') + print_cmd_modes.add_argument('-a', '--answer', help='Only print the answer', action='store_true') + print_cmd_modes.add_argument('-S', '--only-source-code', help='Only print embedded source code', action='store_true') argcomplete.autocomplete(parser) return parser From ed379ed5354fa0ecd1a5b2eda3aa85c1b63cb5d9 Mon Sep 17 00:00:00 2001 From: juk0de Date: Wed, 20 Sep 2023 09:04:40 +0200 Subject: [PATCH 8/9] print_cmd: added option to print latest message --- chatmastermind/commands/print.py | 50 ++++++++++++++++++++++---------- chatmastermind/main.py | 4 ++- 2 files changed, 37 insertions(+), 17 deletions(-) diff --git a/chatmastermind/commands/print.py b/chatmastermind/commands/print.py index 3d2b990..d2a66a1 100644 --- a/chatmastermind/commands/print.py +++ b/chatmastermind/commands/print.py @@ -3,25 +3,43 @@ import argparse from pathlib import Path from ..configuration import Config from ..message import Message, MessageError +from ..chat import ChatDB + + +def print_message(message: Message, args: argparse.Namespace) -> None: + """ + Print given message according to give arguments. + """ + 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()) 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) + # print given file + if args.file is not None: + fname = Path(args.file) + try: + message = Message.from_file(fname) + if message: + print_message(message, args) + except MessageError: + print(f"File is not a valid message: {args.file}") + sys.exit(1) + # print latest message + elif args.latest: + chat = ChatDB.from_dir(Path(config.cache), Path(config.db)) + latest = chat.msg_latest(loc='disk') + if not latest: + print("No message found!") + sys.exit(1) + print_message(latest, args) diff --git a/chatmastermind/main.py b/chatmastermind/main.py index 418dafc..62c4539 100755 --- a/chatmastermind/main.py +++ b/chatmastermind/main.py @@ -114,7 +114,9 @@ def create_parser() -> argparse.ArgumentParser: help="Print message files.", aliases=['p']) print_cmd_parser.set_defaults(func=print_cmd) - print_cmd_parser.add_argument('-f', '--file', help='Print given message file', required=True, metavar='FILE') + print_group = print_cmd_parser.add_mutually_exclusive_group(required=True) + print_group.add_argument('-f', '--file', help='Print given message file', metavar='FILE') + print_group.add_argument('-l', '--latest', help='Print latest message', action='store_true') print_cmd_modes = print_cmd_parser.add_mutually_exclusive_group() print_cmd_modes.add_argument('-q', '--question', help='Only print the question', action='store_true') print_cmd_modes.add_argument('-a', '--answer', help='Only print the answer', action='store_true') From ac3c19739d4d8826e9fa2ace93dc4789dd596d9b Mon Sep 17 00:00:00 2001 From: juk0de Date: Wed, 20 Sep 2023 09:35:58 +0200 Subject: [PATCH 9/9] README: updates and fixes --- README.md | 130 +++++++++++++++++++++++++++++------------------------- 1 file changed, 69 insertions(+), 61 deletions(-) diff --git a/README.md b/README.md index 00f4720..223ea85 100644 --- a/README.md +++ b/README.md @@ -46,79 +46,80 @@ cmm [global options] command [command options] The `question` command is used to ask, create, and process questions. ```bash -cmm question [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-o OUTTAGS]... [-A AI] [-M MODEL] [-n NUM] [-m MAX] [-T TEMP] (-a ASK | -c CREATE | -r REPEAT | -p PROCESS) [-O] [-s SOURCE]... [-S SOURCE]... +cmm question [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-o OUTTAGS]... [-A AI_ID] [-M MODEL] [-n NUM] [-m MAX] [-T TEMP] (-a QUESTION | -c QUESTION | -r [MESSAGE ...] | -p [MESSAGE ...]) [-O] [-s FILE]... [-S FILE]... ``` -* `-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 +* `-t, --or-tags OTAGS`: List of tags (one must match) +* `-k, --and-tags ATAGS`: List of tags (all must match) +* `-x, --exclude-tags XTAGS`: List of tags to exclude +* `-o, --output-tags OUTTAGS`: List of output tags (default: use input tags) +* `-A, --AI AI_ID`: AI ID to use +* `-M, --model MODEL`: Model to use +* `-n, --num-answers NUM`: Number of answers to request +* `-m, --max-tokens MAX`: Max. number of tokens +* `-T, --temperature TEMP`: Temperature value +* `-a, --ask QUESTION`: Ask a question +* `-c, --create QUESTION`: Create a question +* `-r, --repeat [MESSAGE ...]`: Repeat a question +* `-p, --process [MESSAGE ...]`: Process existing questions +* `-O, --overwrite`: Overwrite existing messages when repeating them +* `-s, --source-text FILE`: Add content of a file to the query +* `-S, --source-code FILE`: Add source code file content to the chat history #### Hist The `hist` command is used to print the chat history. ```bash -cmm hist [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-w] [-W] [-S] [-A ANSWER] [-Q QUESTION] +cmm hist [-t OTAGS]... [-k ATAGS]... [-x XTAGS]... [-w] [-W] [-S] [-A SUBSTRING] [-Q SUBSTRING] ``` -* `-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 +* `-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`: Only print embedded source code +* `-A, --answer SUBSTRING`: Search for answer substring +* `-Q, --question SUBSTRING`: Search for question substring #### Tags The `tags` command is used to manage tags. ```bash -cmm tags (-l | -p PREFIX | -c CONTENT) +cmm tags (-l | -p PREFIX | -c SUBSTRING) ``` -* `-l, --list` : List all tags and their frequency -* `-p, --prefix PREFIX` : Filter tags by prefix -* `-c, --contain CONTENT` : Filter tags by contained substring +* `-l, --list`: List all tags and their frequency +* `-p, --prefix PREFIX`: Filter tags by prefix +* `-c, --contain SUBSTRING`: Filter tags by contained substring #### Config The `config` command is used to manage the configuration. ```bash -cmm config (-l | -m | -c CREATE) +cmm config (-l | -m | -c FILE) ``` -* `-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 +* `-l, --list-models`: List all available models +* `-m, --print-model`: Print the currently configured model +* `-c, --create FILE`: Create config with default settings in the given file #### Print The `print` command is used to print message files. ```bash -cmm print -f FILE [-q | -a | -S] +cmm print (-f FILE | -l) [-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`: Print given file +* `-l, --latest`: Print latest message +* `-q, --question`: Only print the question +* `-a, --answer`: Only print the answer +* `-S, --only-source-code`: Only print embedded source code ### Examples @@ -160,18 +161,27 @@ cmm print -f example.yaml ## Configuration -The configuration file (`.config.yaml`) should contain the following fields: +The default configuration filename is `.config.yaml` (it is searched in the current working directory). +Use the command `cmm config --create ` to create a default configuration: -- `openai`: - - `api_key`: Your OpenAI API key. - - `model`: The name of the OpenAI model to use (e.g. "text-davinci-002"). - - `temperature`: The temperature value for the model. - - `max_tokens`: The maximum number of tokens for the model. - - `top_p`: The top P value for the model. - - `frequency_penalty`: The frequency penalty value. - - `presence_penalty`: The presence penalty value. -- `system`: The system message used to set the behavior of the AI. -- `db`: The directory where the question-answer pairs are stored in YAML files. +``` +cache: . +db: ./db/ +ais: + myopenai: + name: openai + model: gpt-3.5-turbo-16k + api_key: 0123456789 + temperature: 1.0 + max_tokens: 4000 + top_p: 1.0 + frequency_penalty: 0.0 + presence_penalty: 0.0 + system: You are an assistant +``` + +Each AI has its own section and the name of that section is called the 'AI ID' (in the example above it is `myopenai`). +The AI ID can be any string, as long as it's unique within the `ais` section. The AI ID is used for all commands that support the `AI` parameter and it's also stored within each message file. ## Autocompletion @@ -186,33 +196,33 @@ After adding this line, restart your shell or run `source pyenv install 3.11.4 pyenv virtualenv 3.11.4 py311 @@ -223,5 +233,3 @@ pyenv activate py311 ## License This project is licensed under the terms of the WTFPL License. - -