configuration: added tests

chatmastermind/ai.py

@@ -33,18 +33,23 @@ class AI(Protocol):
     The base class for AI clients.
     """
 
+    ID: str
     name: str
     config: AIConfig
 
     def request(self,
                 question: Message,
-                context: Chat,
+                chat: Chat,
                 num_answers: int = 1,
                 otags: Optional[set[Tag]] = None) -> AIResponse:
         """
-        Make an AI request, asking the given question with the given
-        context (i. e. chat history). The nr. of requested answers
-        corresponds to the nr. of messages in the '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
 

chatmastermind/ai_factory.py

@@ -3,18 +3,24 @@ Creates different AI instances, based on the given configuration.
 """
 
 import argparse
-from .configuration import Config
+from typing import cast
+from .configuration import Config, OpenAIConfig, default_ai_ID
 from .ai import AI, AIError
-from .ais.openai import OpenAI
+from .ais.openai_cmm import OpenAI
 
 
 def create_ai(args: argparse.Namespace, config: Config) -> AI:
     """
     Creates an AI subclass instance from the given args and configuration.
     """
-    if args.ai == 'openai':
-        # FIXME: create actual 'OpenAIConfig' and set values from 'args'
-        # FIXME: use actual name from config
-        return OpenAI("openai", config.openai)
+    if args.ai:
+        ai_conf = config.ais[args.ai]
+    elif default_ai_ID in config.ais:
+        ai_conf = config.ais[default_ai_ID]
+    else:
+        raise AIError("No AI name given and no default exists")
+
+    if ai_conf.name == 'openai':
+        return OpenAI(cast(OpenAIConfig, ai_conf))
     else:
         raise AIError(f"AI '{args.ai}' is not supported")

chatmastermind/ais/openai_cmm.py

@@ -17,9 +17,11 @@ class OpenAI(AI):
     The OpenAI AI client.
     """
 
-    def __init__(self, name: str, config: OpenAIConfig) -> None:
-        self.name = name
+    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,
@@ -31,8 +33,7 @@ class OpenAI(AI):
         chat history. The nr. of requested answers corresponds to the
         nr. of messages in the 'AIResponse'.
         """
-        # FIXME: use real 'system' message (store in OpenAIConfig)
-        oai_chat = self.openai_chat(chat, "system", question)
+        oai_chat = self.openai_chat(chat, self.config.system, question)
         response = openai.ChatCompletion.create(
             model=self.config.model,
             messages=oai_chat,

chatmastermind/commands/config.py

@@ -0,0 +1,11 @@
+import argparse
+from pathlib import Path
+from ..configuration import Config
+
+
+def config_cmd(args: argparse.Namespace) -> None:
+    """
+    Handler for the 'config' command.
+    """
+    if args.create:
+        Config.create_default(Path(args.create))

chatmastermind/commands/hist.py

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,19 @@
+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:
+            print(message.to_str(source_code_only=args.source_code_only))
+    except MessageError:
+        print(f"File is not a valid message: {args.file}")
+        sys.exit(1)

chatmastermind/commands/question.py

@@ -0,0 +1,49 @@
+import argparse
+from pathlib import Path
+from ..configuration import Config
+from ..chat import ChatDB
+from ..message import Message, Question
+from ..ai_factory import create_ai
+from ..ai import AI, AIResponse
+
+
+def question_cmd(args: argparse.Namespace, config: Config) -> None:
+    """
+    Handler for the 'question' command.
+    """
+    chat = ChatDB.from_dir(cache_path=Path('.'),
+                           db_path=Path(config.db))
+    # if it's a new question, create and store it immediately
+    if args.ask or args.create:
+        # FIXME: add sources to the question
+        message = Message(question=Question(args.question),
+                          tags=args.ouput_tags,  # FIXME
+                          ai=args.ai,
+                          model=args.model)
+        chat.add_to_cache([message])
+    if args.create:
+        return
+
+    # create the correct AI instance
+    ai: AI = create_ai(args, config)
+    if args.ask:
+        response: AIResponse = ai.request(message,
+                                          chat,
+                                          args.num_answers,  # FIXME
+                                          args.otags)  # FIXME
+        assert response
+        # TODO:
+        # * add answer to the message above (and create
+        #   more messages for any additional answers)
+        pass
+    elif args.repeat:
+        lmessage = chat.latest_message()
+        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:
+        # TODO: process either all questions without an
+        # answer or the one(s) given in 'args.process'
+        pass

chatmastermind/commands/tags.py

@@ -0,0 +1,17 @@
+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.tags_frequency(args.prefix, args.contain)
+        for tag, freq in tags_freq.items():
+            print(f"- {tag}: {freq}")
+    # TODO: add renaming

chatmastermind/configuration.py

@@ -1,17 +1,40 @@
 import yaml
-from typing import Type, TypeVar, Any
-from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Type, TypeVar, Any, Optional, ClassVar
+from dataclasses import dataclass, asdict, field
 
 ConfigInst = TypeVar('ConfigInst', bound='Config')
+AIConfigInst = TypeVar('AIConfigInst', bound='AIConfig')
 OpenAIConfigInst = TypeVar('OpenAIConfigInst', bound='OpenAIConfig')
 
 
+supported_ais: list[str] = ['openai']
+default_ai_ID: str = 'default'
+default_config_path = '.config.yaml'
+
+
+class ConfigError(Exception):
+    pass
+
+
 @dataclass
 class AIConfig:
     """
     The base class of all AI configurations.
     """
-    name: str
+    # 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
+
+    # 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
@@ -19,21 +42,27 @@ class OpenAIConfig(AIConfig):
     """
     The OpenAI section of the configuration file.
     """
-    api_key: str
-    model: str
-    temperature: float
-    max_tokens: int
-    top_p: float
-    frequency_penalty: float
-    presence_penalty: float
+    name: ClassVar[str] = 'openai'
+
+    # all members have default values, so we can easily create
+    # a default configuration
+    ID: str = 'default'
+    api_key: str = '0123456789'
+    system: str = 'You are an assistant'
+    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
 
     @classmethod
     def from_dict(cls: Type[OpenAIConfigInst], source: dict[str, Any]) -> OpenAIConfigInst:
         """
         Create OpenAIConfig from a dict.
         """
-        return cls(
-            name='OpenAI',
+        res = cls(
+            system=str(source['system']),
             api_key=str(source['api_key']),
             model=str(source['model']),
             max_tokens=int(source['max_tokens']),
@@ -42,6 +71,30 @@ class OpenAIConfig(AIConfig):
             frequency_penalty=float(source['frequency_penalty']),
             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"AI '{name}' is not supported")
+
+
+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
@@ -49,30 +102,52 @@ class Config:
     """
     The configuration file structure.
     """
-    system: str
-    db: str
-    openai: OpenAIConfig
+    # 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)
 
     @classmethod
     def from_dict(cls: Type[ConfigInst], source: dict[str, Any]) -> ConfigInst:
         """
-        Create Config from a dict.
+        Create Config from a dict (with the same format as the config file).
         """
+        # 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']),
-            openai=OpenAIConfig.from_dict(source['openai'])
+            ais=ais
         )
 
+    @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, path: str) -> None:
-        with open(path, 'w') as f:
-            yaml.dump(asdict(self), f, sort_keys=False)
+    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 as_dict(self) -> dict[str, Any]:
-        return asdict(self)
+        res = asdict(self)
+        for ID, conf in res['ais'].items():
+            conf.update({'name': self.ais[ID].name})
+        return res

chatmastermind/main.py

@@ -6,12 +6,14 @@ import sys
 import argcomplete
 import argparse
 from pathlib import Path
-from .configuration import Config, default_config_path
-from .chat import ChatDB
-from .message import Message, MessageFilter, MessageError, Question
-from .ai_factory import create_ai
-from .ai import AI, AIResponse
 from typing import Any
+from .configuration import Config, default_config_path
+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
 
 
 def tags_completer(prefix: str, parsed_args: Any, **kwargs: Any) -> list[str]:
@@ -19,101 +21,6 @@ def tags_completer(prefix: str, parsed_args: Any, **kwargs: Any) -> list[str]:
     return list(Message.tags_from_dir(Path(config.db), prefix=prefix))
 
 
-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.tags_frequency(args.prefix, args.contain)
-        for tag, freq in tags_freq.items():
-            print(f"- {tag}: {freq}")
-    # TODO: add renaming
-
-
-def config_cmd(args: argparse.Namespace) -> None:
-    """
-    Handler for the 'config' command.
-    """
-    if args.create:
-        Config.create_default(Path(args.create))
-
-
-def question_cmd(args: argparse.Namespace, config: Config) -> None:
-    """
-    Handler for the 'question' command.
-    """
-    chat = ChatDB.from_dir(cache_path=Path('.'),
-                           db_path=Path(config.db))
-    # if it's a new question, create and store it immediately
-    if args.ask or args.create:
-        # FIXME: add sources to the question
-        message = Message(question=Question(args.question),
-                          tags=args.ouput_tags,  # FIXME
-                          ai=args.ai,
-                          model=args.model)
-        chat.add_to_cache([message])
-    if args.create:
-        return
-
-    # create the correct AI instance
-    ai: AI = create_ai(args, config)
-    if args.ask:
-        response: AIResponse = ai.request(message,
-                                          chat,
-                                          args.num_answers,  # FIXME
-                                          args.otags)  # FIXME
-        assert response
-        # TODO:
-        # * add answer to the message above (and create
-        #   more messages for any additional answers)
-        pass
-    elif args.repeat:
-        lmessage = chat.latest_message()
-        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:
-        # TODO: process either all questions without an
-        # answer or the one(s) given in 'args.process'
-        pass
-
-
-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)
-
-
-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:
-            print(message.to_str(source_code_only=args.source_code_only))
-    except MessageError:
-        print(f"File is not a valid message: {args.file}")
-        sys.exit(1)
-
-
 def create_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         description="ChatMastermind is a Python application that automates conversation with AI")

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"],
+    packages=find_packages() + ["chatmastermind.ais", "chatmastermind.commands"],
     classifiers=[
         "Development Status :: 3 - Alpha",
         "Environment :: Console",

tests/test_configuration.py

@@ -0,0 +1,139 @@
+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': {
+                '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
+                }
+            }
+        }
+        config = Config.from_dict(source_dict)
+        self.assertEqual(config.db, './test_db/')
+        self.assertEqual(len(config.ais), 1)
+        self.assertEqual(config.ais['default'].name, 'openai')
+        self.assertEqual(cast(OpenAIConfig, config.ais['default']).system, 'Custom system')
+        # check that 'ID' has been added
+        self.assertEqual(config.ais['default'].ID, 'default')
+
+    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={
+                'default': OpenAIConfig(
+                    ID='default',
+                    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']['default']['system'], 'Custom system')