adding latest testing + docstrings

.vscode/settings.json

@@ -3,5 +3,6 @@
     "python.linting.prospectorEnabled": true,
     "python.linting.enabled": true,
     "python.pythonPath": ".venv/bin/python",
-    "restructuredtext.confPath": "${workspaceFolder}/docs/source"
+    "restructuredtext.confPath": "${workspaceFolder}/docs/source",
+    "peacock.color": "#307E6A"
 }

TODO

@@ -0,0 +1,3 @@
+
+Todo:
+  ☐ Item

old_src/panaetius/config.py

@@ -9,7 +9,6 @@ from panaetius.db import Mask
 # __all__ = ['Config']
 
 
-@export
 class Config:
 
     """Handles the config options for the module and stores config variables
@@ -52,34 +51,6 @@ class Config:
     def read_config(self, path: str, write: bool = False) -> Union[dict, None]:
         """Reads the toml config file from `path` if it exists.
 
-        Parameters
-        ----------
-        path : str
-            Path to config file. Should not contain `config.toml`
-        header : str
-            Header to overwrite if using in a module.
-
-            Example: ``path = '~/.config/panaetius'``
-
-        Returns
-        -------
-        Union[dict, None]
-            Returns a dict if the file is found else returns nothing.
-
-            The dict contains a key for each header. Each key corresponds to a
-            dictionary containing a key, value pair for each config under
-            that header.
-
-            Example::
-
-                [panaetius]
-
-                [panaetius.foo]
-                foo = bar
-
-            Returns a dict:
-
-                ``{'panaetius' : {foo: {'foo': 'bar'}}}``
         """
 
         path += 'config.toml' if path[-1] == '/' else '/config.toml'

old_src/panaetius/config_inst.py

@@ -0,0 +1,9 @@
+import os
+
+from panaetius.header import __header__
+from panaetius.config import Config
+
+
+DEFAULT_CONFIG_PATH = f"~/.config/{__header__.lower()}"
+CONFIG_PATH = os.environ.get(f"{__header__.upper()}_CONFIG_PATH", DEFAULT_CONFIG_PATH)
+CONFIG = Config(CONFIG_PATH)

panaetius/__init__.py

@@ -0,0 +1,9 @@
+"""
+panaetius - a utility library to read variables and provide convenient logging.
+
+Author: Daniel Tomlinson (dtomlinson@panaetius.co.uk)
+"""
+
+from panaetius.config import Config
+from panaetius.library import set_config
+from panaetius.logging import set_logger, SimpleLogger, AdvancedLogger, CustomLogger

panaetius/config.py

@@ -0,0 +1,169 @@
+"""
+Access variables from a config file or an environment variable.
+
+This module defines the `Config` class to interact and read variables from either a
+`config.toml` or an environment variable.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import pathlib
+from typing import Any
+
+import toml
+
+from panaetius.exceptions import KeyErrorTooDeepException, InvalidPythonException
+
+
+class Config:
+    """The configuration class to access variables."""
+
+    def __init__(self, header_variable: str, config_path: str = "") -> None:
+        """
+        Create a Config object to set and access variables.
+
+        Args:
+            header_variable (str): Your header variable name.
+            config_path (str, optional): The path where the header directory is stored.
+                Defaults to `~/.config`.
+
+        Example:
+            A header of `data_analysis` with a config_path of `~/myapps` will define
+                a config file in `~/myapps/data_analysis/config.toml`.
+        """
+        self.header_variable = header_variable
+        self.config_path = (
+            pathlib.Path(config_path)
+            if config_path
+            else pathlib.Path.home() / ".config"
+        )
+        self._missing_config = self._check_config_file_exists()
+
+        # default logging options
+        self.logging_path: str | None = None
+        self.logging_rotate_bytes: int = 0
+        self.logging_backup_count: int = 0
+
+    @property
+    def config(self) -> dict:
+        """
+        Return the contents of the config file. If missing returns an empty dictionary.
+
+        Returns:
+            dict: The contents of the `.toml` loaded as a python dictionary.
+        """
+        config_file_location = self.config_path / self.header_variable / "config.toml"
+        try:
+            with open(config_file_location, "r", encoding="utf-8") as config_file:
+                return dict(toml.load(config_file))
+        except FileNotFoundError:
+            return {}
+
+    def get_value(self, key: str, default: Any) -> Any:
+        """
+        Get the value of a variable from the key name.
+
+        The key can either be one (`value`) or two (`data.value`) levels deep.
+
+        A key of (`value`) (with a header of `data_analysis`) would refer to a
+        `config.toml` of:
+
+        ```
+        [data_analysis]
+        value = "some value"
+        ```
+
+        or an environment variable of `DATA_ANALYSIS_VALUE="'some value'"`.
+
+        A key of (`data.value`) would refer to a `config.toml` of:
+        ```
+        [data_analysis.data]
+        value = "some value"
+        ```
+        or an environment variable of `DATA_ANALYSIS_DATA_VALUE="'some value'"`.
+
+        Args:
+            key (str): The key of the variable.
+            default (Any): The default value if the key cannot be found in the config
+                file, or an environment variable.
+
+        Returns:
+            Any: The value of the variable.
+        """
+        env_key = f"{self.header_variable.upper()}_{key.upper().replace('.', '_')}"
+
+        if not self._missing_config:
+            # look in the config file
+            return self._get_config_value(env_key, key, default)
+        # no config file, look for env vars
+        return self._get_env_value(env_key, default)
+
+    def _check_config_file_exists(self) -> bool:
+        config_file_location = self.config_path / self.header_variable / "config.toml"
+        try:
+            with open(config_file_location, "r", encoding="utf-8"):
+                return False
+        except FileNotFoundError:
+            return True
+
+    def _get_config_value(self, env_key: str, key: str, default: Any) -> Any:
+        try:
+            # look under top header
+            # REVIEW: could this be auto handled for a key of arbitrary length?
+
+            # check for env variable and have it take priority
+            value = os.environ.get(env_key.replace("-", "_"))
+            if value is not None:
+                return self.__get_config_value_env_var_override(value)
+
+            if len(key.split(".")) > 2:
+                raise KeyErrorTooDeepException(
+                    f"Your key of {key} can only be 2 levels deep maximum. "
+                    f"You have {len(key.split('.'))}"
+                )
+            if len(key.split(".")) == 1:
+                return self.__get_config_value_key_split_once(key)
+            if len(key.split(".")) == 2:
+                return self.__get_config_value_key_split_twice(key)
+            raise KeyError()
+
+        except (KeyError, TypeError):
+            if value is None:
+                return self.__get_config_value_missing_key_value_is_none(default)
+            # if env var is present, load it
+            return self.__get_config_value_missing_key_value_is_not_none(value)
+
+    def __get_config_value_key_split_once(self, key: str) -> Any:
+        name = key.lower()
+        return self.config[self.header_variable][name]
+
+    def __get_config_value_key_split_twice(self, key: str) -> Any:
+        section, name = key.lower().split(".")
+        return self.config[self.header_variable][section][name]
+
+    def __get_config_value_missing_key_value_is_none(self, default: Any) -> Any:
+        return self.__load_default_value(default)
+
+    def __get_config_value_missing_key_value_is_not_none(self, value: str) -> Any:
+        return self.__load_value(value)
+
+    def __get_config_value_env_var_override(self, value: str) -> Any:
+        return self.__load_value(value)
+
+    def _get_env_value(self, env_key: str, default: Any) -> Any:  # noqa
+        # look for an environment variable, fallback to default
+        value = os.environ.get(env_key.replace("-", "_"))
+        if value is None:
+            return self.__load_default_value(default)
+        return self.__load_value(value)
+
+    def __load_value(self, value: str) -> Any:  # noqa
+        try:
+            return ast.literal_eval(value)
+        except (ValueError, SyntaxError):
+            raise InvalidPythonException(f"{value} is not valid Python.")  # noqa
+
+    def __load_default_value(self, default: Any) -> Any:  # noqa
+        return default

panaetius/exceptions.py

@@ -0,0 +1,13 @@
+"""Exceptions for the module."""
+
+
+class KeyErrorTooDeepException(Exception):
+    pass
+
+
+class LoggingDirectoryDoesNotExistException(Exception):
+    pass
+
+
+class InvalidPythonException(Exception):
+    pass

panaetius/library.py

@@ -0,0 +1,43 @@
+"""Module to provide functionality when interacting with variables."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from panaetius import Config
+
+
+def set_config(
+    config_inst: Config,
+    key: str,
+    default: Any = None,
+) -> None:
+    """
+    Define a variable to be read from a `config.toml` or an environment variable.
+
+    Args:
+        config_inst (Config): The instance of the `Config` class.
+        key (str): The key of the variable.
+        default (Any, optional): The default value if the key cannot be found in the config
+            file, or an environment variable. Defaults to None.
+
+    Example:
+        `set_config(CONFIG, "value", default=[1, 2])` would look for a
+        `config.toml` with the following structure (with `CONFIG` having a header of
+        `data_analysis`):
+
+        ```
+        [data_analysis]
+        value = "some value"
+        ```
+
+        Or an environment variable of `DATA_ANALYSIS_VALUE="'some value'"`.
+
+        If found, this value can be access with `CONFIG.value` which would return
+        `some_value`.
+
+        If neither the environment variable nor the `config.toml` are present, the
+        default of `[1, 2]` would be returned instead.
+    """
+    config_var = key.lower().replace(".", "_")
+    setattr(config_inst, config_var, config_inst.get_value(key, default))

panaetius/logging.py

@@ -0,0 +1,141 @@
+"""Module to define a convenient logger instance with json formatted output."""
+
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+import logging
+from logging.handlers import RotatingFileHandler
+import pathlib
+import sys
+
+from panaetius import Config
+from panaetius.library import set_config
+from panaetius.exceptions import LoggingDirectoryDoesNotExistException
+
+
+def set_logger(config_inst: Config, logging_format_inst: LoggingData) -> logging.Logger:
+    """
+    Set and return a `logging.Logger` instance for quick logging.
+
+    `logging_format_inst` should be an instance of either SimpleLogger, AdvancedLogger,
+    or CustomLogger.
+
+    SimpleLogger and AdvancedLogger define a logging format and a logging level info.
+
+    CustomLogger defines a logging level info and should have a logging format passed
+    in.
+
+    Logging to a file is defined by a `logging.path` key set on `Config`. This path
+    should exist as it will not be created.
+
+    Args:
+        config_inst (Config): The instance of the `Config` class.
+        logging_format_inst (LoggingData): The instance of the `LoggingData` class.
+
+    Raises:
+        LoggingDirectoryDoesNotExistException: If the logging directory specified does
+            not exist.
+
+    Returns:
+        logging.Logger: An configured instance of `logging.Logger` ready to be used.
+
+    Example:
+
+        ```
+        logger = set_logger(CONFIG, SimpleLogger())
+
+        logger.info("some logging message")
+        ```
+
+        Would create a logging output of:
+
+        ```
+        {
+            "time": "2021-10-18 02:26:24,037",
+            "logging_level":"INFO",
+            "message": "some logging message"
+        }
+        ```
+
+    """
+    logger = logging.getLogger(config_inst.header_variable)
+    log_handler_sys = logging.StreamHandler(sys.stdout)
+
+    # configure file handler
+    if config_inst.logging_path is not None:
+        logging_file = (
+            pathlib.Path(config_inst.logging_path)
+            / config_inst.header_variable
+            / f"{config_inst.header_variable}.log"
+        ).expanduser()
+
+        if not logging_file.parents[0].exists():
+            raise LoggingDirectoryDoesNotExistException()
+
+        if config_inst.logging_rotate_bytes == 0:
+            set_config(config_inst, "logging.rotate_bytes", 512000)
+        if config_inst.logging_backup_count == 0:
+            set_config(config_inst, "logging.backup_count", 3)
+
+        log_handler_file = RotatingFileHandler(
+            str(logging_file),
+            "a",
+            config_inst.logging_rotate_bytes,
+            config_inst.logging_backup_count,
+        )
+
+        log_handler_file.setFormatter(logging.Formatter(logging_format_inst.format))
+        logger.addHandler(log_handler_file)
+
+    # configure stdout handler
+    log_handler_sys.setFormatter(logging.Formatter(logging_format_inst.format))
+    logger.addHandler(log_handler_sys)
+    logger.setLevel(logging_format_inst.logging_level)
+    return logger
+
+
+class LoggingData(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def format(self) -> str:
+        pass
+
+    @abstractmethod
+    def __init__(self, logging_level: str):
+        self.logging_level = logging_level
+
+
+class SimpleLogger(LoggingData):
+    @property
+    def format(self) -> str:
+        return str(
+            '{\n\t"time": "%(asctime)s",\n\t"logging_level":'
+            '"%(levelname)s",\n\t"message": "%(message)s"\n}',
+        )
+
+    def __init__(self, logging_level: str = "INFO"):
+        self.logging_level = logging_level
+
+
+class AdvancedLogger(LoggingData):
+    @property
+    def format(self) -> str:
+        return str(
+            '{\n\t"time": "%(asctime)s",\n\t"file_name": "%(filename)s",'
+            '\n\t"module": "%(module)s",\n\t"function":"%(funcName)s",\n\t'
+            '"line_number": "%(lineno)s",\n\t"logging_level":'
+            '"%(levelname)s",\n\t"message": "%(message)s"\n}',
+        )
+
+    def __init__(self, logging_level: str = "INFO"):
+        self.logging_level = logging_level
+
+
+class CustomLogger(LoggingData):
+    @property
+    def format(self) -> str:
+        return str(self._format)
+
+    def __init__(self, logging_format: str, logging_level: str = "INFO"):
+        self.logging_level = logging_level
+        self._format = logging_format

prospector.yaml

@@ -0,0 +1,117 @@
+output-format: vscode
+doc-warnings: true
+strictness: none
+
+ignore-patterns:
+  - (^|/)\..+
+
+# https://pylint.pycqa.org/en/latest/technical_reference/features.html
+pylint:
+  run: true
+  disable:
+    # disables TODO warnings
+    - fixme
+# !doc docstrings
+    # - missing-module-docstring
+    # - missing-class-docstring
+    # - missing-function-docstring
+# ! doc end of docstrings
+    # disables warnings about abstract methods not overridden
+    - abstract-method
+    # used when an ancestor class method has an __init__ method which is not called by a derived class.
+    - super-init-not-called
+    # either all return statements in a function should return an expression, or none of them should.
+    # - inconsistent-return-statements
+    # Used when an expression that is not a function call is assigned to nothing. Probably something else was intended.
+    # - expression-not-assigned
+    # Used when a line is longer than a given number of characters.
+    - line-too-long
+  enable:
+  options:
+    max-locals: 15
+    max-returns: 6
+    max-branches: 12
+    max-statements: 50
+    max-parents: 7
+    max-attributes: 20
+    min-public-methods: 0
+    max-public-methods: 25
+    max-module-lines: 1000
+    max-line-length: 88
+    max-args: 8
+
+mccabe:
+  run: true
+  options:
+    max-complexity: 10
+
+# https://pep8.readthedocs.io/en/release-1.7.x/intro.html#error-codes
+pep8:
+  run: true
+  options:
+    max-line-length: 88
+    single-line-if-stmt: n
+  disable:
+    # line too long
+    - E501
+
+pyroma:
+  run: false
+  disable:
+    - PYR19
+    - PYR16
+
+# https://pep257.readthedocs.io/en/latest/error_codes.html
+# http://www.pydocstyle.org/en/6.1.1/error_codes.html
+pep257:
+  disable:
+# !doc docstrings
+    # Missing docstring in __init__
+    # - D107
+    # Missing docstring in public module
+    # - D100
+    # Missing docstring in public class
+    # - D101
+    # Missing docstring in public method
+    # - D102
+    # Missing docstring in public function
+    # - D103
+    # Multi-line docstring summary should start at the second line
+    # - D213
+    # First word of the docstring should not be This
+    # - D404
+    # DEFAULT IGNORES
+    # 1 blank line required before class docstring
+    - D203
+    # Multi-line docstring summary should start at the first line
+    - D212
+# !doc end of docstrings
+    # Section name should end with a newline
+    - D406
+    # Missing dashed underline after section
+    - D407
+    # Missing blank line after last section
+    - D413
+
+# https://flake8.pycqa.org/en/latest/user/error-codes.html
+pyflakes:
+  disable:
+    # module imported but unused
+    - F401
+
+dodgy:
+  run: true
+
+bandit:
+  run: true
+  # options:
+    # ignore assert warning
+    # - B101
+
+mypy:
+  run: true
+  options:
+    # https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-type-hints-for-third-party-library
+    ignore-missing-imports: true
+    # https://mypy.readthedocs.io/en/stable/running_mypy.html#following-imports
+    follow-imports: normal

pyproject.toml

@@ -28,19 +28,12 @@ toml = "^0.10.0"
 pylite = "^0.1.0"
 
 [tool.poetry.dev-dependencies]
-pytest = "^3.0"
+prospector = {extras = ["with_bandit", "with_mypy"], version = "^1.5.1"}
-autopep8 = "^1.4"
+types-toml = "^0.10.1"
-pudb = "^2019.2"
+pytest = "^6.2.5"
-McCabe = "^0.6.1"
+pytest-datadir = "^1.3.1"
-YAPF = "^0.29.0"
+pytest-xdist = "^2.4.0"
-pydocstyle = "^5.0"
+coverage = "^6.0.2"
-Pyflakes = "^2.1"
-Rope = "^0.16.0"
-python-language-server = "^0.31.4"
-pycodestyle = "^2.5"
-sphinx = "^2.3"
-sphinx_rtd_theme = "^0.4.3"
-prospector = "^1.3.0"
 
 [build-system]
 requires = ["poetry>=0.12"]

pytest.ini

@@ -0,0 +1,3 @@
+; ; parallel tests with pytest-xdist
+; [pytest]
+; addopts=-n4

rewrite.todo

@@ -0,0 +1,70 @@
+Coding:
+    No Config File:
+        ✔ Handle if a bool is passed in as a default @done(21-10-16 05:25)
+        needs to be lower case in the toml, need a check for this
+
+    Config File:
+        ✔ Handle if a bool is passed in as a default @done(21-10-16 05:25)
+        needs to be lower case in the toml, need a check for this
+
+    Logging:
+        ✔ Create SimpleLogger, AdvancedLogger, CustomLogger classes @done(21-10-16 16:22)
+        should simply have the different logging strings to output
+        should both specify whether to save to file or not
+        ✔ Logging path should take by default the config path unless overwritten? @done(21-10-16 23:49)
+
+    Errors:
+        ✔ Check logging path + config path are valid, if not raise error. @done(21-10-18 00:04)
+            ✔ Add tests for these. @done(21-10-18 00:04)
+        ✔ Check for a key > 2 levels, raise custom error, write test @done(21-10-17 23:30)
+
+    Linting:
+        ✔ Check all functions and annotations. @done(21-10-18 01:07)
+
+    Docstrings:
+        ✔ Write the docstrings for public functions/methods. @done(21-10-18 02:29)
+
+    Functionality:
+        ✔ When both a config file and a env var is found, use the env var. @done(21-10-18 00:38)
+
+Documentation:
+    ☐ Rewrite documentation using `mkdocs` and using `.md`. @2h
+
+Misc:
+    ☐ Use the python runner to build the docs & run the tests (including coverage html)
+        coverage run -m pytest && coverage report && coverage html
+        ☐ document this in trilium
+
+Tests:
+    Bugfixes:
+        ✔ If loading from a default, don't covert to TOML @done(21-10-17 20:33)
+        ✔ Env Vars should be given as python objects @done(21-10-17 20:33)
+            The string or node provided may only consist of the following Python literal structures: strings, bytes, numbers, tuples, lists, dicts, sets, booleans, and None.
+            use ast.literal_eval()
+            https://docs.python.org/3/library/ast.html#ast.literal_eval
+
+    __init__:
+        ✔ Test default config path set to "~/.config" @done(21-10-17 17:25)
+        ✔ Test config path is set when passed in @done(21-10-17 17:25)
+
+    config property:
+        ✔ Check testing config file is returned as dict @done(21-10-17 17:25)
+        ✔ Check _self.missing_config and empty dict is returned @done(21-10-17 17:25)
+
+    get_value:
+        config_file:
+            ✔ Arrays & tables loaded correctly from config file @done(21-10-17 20:34)
+            ✔ test when key length is 1 the value is returned @done(21-10-17 18:55)
+            ✔ test when key length is 2 the value is returned @done(21-10-17 18:55)
+            ✔ test when key not found and no env var default is loaded @done(21-10-17 19:01)
+                ✔ test bool's are properly converted @done(21-10-17 19:01)
+            ✔ test when key not found and env var is set value is loaded @done(21-10-17 20:43)
+
+        env_var:
+            ✔ check if env key is missing the default is read in @done(21-10-17 20:55)
+            ✔ check if env key is present the values are read in @done(21-10-17 22:24)
+                ✔ parametrise a test to read in values form env vars and they're set correctly @done(21-10-17 22:24)
+            ✔ test that the env var is valid python @done(21-10-18 01:03)
+
+    library:
+        ✔ test set_config works @done(21-10-17 23:29)

src/panaetius/config_inst.py

@@ -1,11 +0,0 @@
-import os
-
-from panaetius.header import __header__
-from panaetius.config import Config
-
-
-DEFAULT_CONFIG_PATH = f'~/.config/{__header__.lower()}'
-CONFIG_PATH = os.environ.get(
-    f'{__header__.upper()}_CONFIG_PATH', DEFAULT_CONFIG_PATH
-)
-CONFIG = Config(CONFIG_PATH)

tests/__header__.py

@@ -1 +0,0 @@
-__header__ = 'panaetius_test'

tests/conftest.py

@@ -0,0 +1,23 @@
+import pytest
+
+
+@pytest.fixture()
+def header():
+    return "panaetius_testing"
+
+
+@pytest.fixture()
+def testing_config_contents():
+    return {
+        "panaetius_testing": {
+            "some_top_string": "some_top_value",
+            "second": {
+                "some_second_string": "some_second_value",
+                "some_second_int": 1,
+                "some_second_float": 1.0,
+                "some_second_list": ["some", "second", "value"],
+                "some_second_table": {"first": ["some", "first", "value"]},
+                "some_second_table_bools": {"bool": [True, False]},
+            },
+        }
+    }

tests/data/without_logging/panaetius_testing/config.toml

@@ -0,0 +1,10 @@
+[panaetius_testing]
+some_top_string = "some_top_value"
+
+[panaetius_testing.second]
+some_second_string = "some_second_value"
+some_second_int = 1
+some_second_float = 1.0
+some_second_list = ["some", "second", "value"]
+some_second_table = { "first" = ["some", "first", "value"] }
+some_second_table_bools = { "bool" = [true, false] }

tests/scratchpad.py

@@ -0,0 +1,57 @@
+import os
+
+from panaetius import Config, set_config, set_logger, SimpleLogger
+
+from panaetius.logging import AdvancedLogger
+
+if __name__ == "__main__":
+    os.environ["PANAETIUS_TEST_PATH"] = '"/usr/local"'
+    os.environ["PANAETIUS_TEST_BOOL"] = "True"
+    # print(os.environ.get("PANAETIUS_TEST_PATH"))
+    # os.environ[
+    #     "PANAETIUS_TEST_TOML_POINTS"
+    # ] = "[ { x = 1, y = 2, z = 3 }, { x = 7, y = 8, z = 9 }, { x = 2, y = 4, z = 8 }]"
+
+    os.environ["PANAETIUS_TEST_NOC_PATH"] = '"/usr/locals"'
+    os.environ["PANAETIUS_TEST_NOC_FLOAT"] = "2.0"
+    os.environ["PANAETIUS_TEST_NOC_BOOL"] = "True"
+    os.environ["PANAETIUS_TEST_NOC_EMBEDDED_PATH"] = '"/usr/local"'
+    os.environ["PANAETIUS_TEST_NOC_EMBEDDED_FLOAT"] = "2.0"
+    os.environ["PANAETIUS_TEST_NOC_EMBEDDED_BOOL"] = "True"
+
+    c = Config("panaetius_test")
+    # c = Config("panaetius_test_noc")
+
+    set_config(c, key="toml.points")
+    set_config(c, key="path", default="some path")
+    set_config(c, key="top", default="some top")
+    set_config(c, key="logging.path")
+    set_config(c, key="nonexistent.item", default="some nonexistent item")
+    set_config(c, key="nonexistent.item")
+    set_config(c, key="toml.points_config")
+    set_config(c, key="float")
+    set_config(c, key="float_str", default="2.0")
+    set_config(c, key="bool")
+    set_config(c, key="noexistbool", default=False)
+    set_config(c, key="middle.middle")
+
+    # set_config(c, key="path")
+    # set_config(c, key="float")
+    # set_config(c, key="bool")
+    # set_config(c, key="noexiststr", default="2.0")
+    # set_config(c, key="noexistfloat", default=2.0)
+    # set_config(c, key="noexistbool", default=False)
+
+    set_config(c, key="embedded.path")
+    set_config(c, key="embedded.float")
+    set_config(c, key="embedded.bool")
+    set_config(c, key="embedded.noexiststr", default="2.0")
+    set_config(c, key="embedded.noexistfloat", default=2.0)
+    set_config(c, key="embedded.noexistbool", default=False)
+
+    # logger = set_logger(c, SimpleLogger())
+    logger = set_logger(c, SimpleLogger(logging_level="DEBUG"))
+    logger.info("some logging message")
+    logger.debug("debugging message")
+    # for i in dir(c):
+    #     logger.debug(i + ": " + str(getattr(c, i)) + " - " + str(type(getattr(c, i))))

tests/test.py

@@ -1,33 +0,0 @@
-import panaetius
-
-# from panaetius import CONFIG as CONFIG
-# from panaetius import logger as logger
-
-print(panaetius.__header__)
-
-panaetius.set_config(panaetius.CONFIG, 'logging.level')
-
-# print(panaetius.CONFIG.logging_format)
-print(panaetius.CONFIG.logging_path)
-print(panaetius.config_inst.CONFIG_PATH)
-
-# panaetius.logger.info('test event')
-
-
-panaetius.logger.info('setting foo.bar value')
-panaetius.set_config(panaetius.CONFIG, 'foo.bar', mask=True)
-
-panaetius.logger.info(f'foo.bar set to {panaetius.CONFIG.foo_bar}')
-
-# print((panaetius.CONFIG.path))
-# print(panaetius.CONFIG.logging_level)
-
-panaetius.set_config(panaetius.CONFIG, 'test', mask=True)
-panaetius.logger.info(f'test_root={panaetius.CONFIG.test}')
-
-print(panaetius.CONFIG.config_file)
-
-# for i in panaetius.CONFIG.deferred_messages:
-#     panaetius.logger.debug(i)
-
-panaetius.logger.info('some logging message')

tests/test_config.py

@@ -0,0 +1,256 @@
+import os
+import pathlib
+from uuid import uuid4
+
+import pytest
+
+import panaetius
+from panaetius.exceptions import InvalidPythonException, KeyErrorTooDeepException
+
+# test config paths
+
+
+def test_default_config_path_set(header):
+    # act
+    config = panaetius.Config(header)
+
+    # assert
+    assert str(config.config_path) == str(pathlib.Path.home() / ".config")
+
+
+def test_user_config_path_set(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+
+    # act
+    config = panaetius.Config(header, config_path)
+
+    # assert
+    assert str(config.config_path) == config_path
+
+
+# test config files
+
+
+def test_config_file_exists(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+
+    # act
+    config = panaetius.Config(header, config_path)
+    _ = config.config
+
+    # assert
+    assert config._missing_config is False
+
+
+def test_config_file_contents_read_success(
+    header, shared_datadir, testing_config_contents
+):
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+
+    # act
+    config = panaetius.Config(header, config_path)
+    config_contents = config.config
+
+    # assert
+    assert config_contents == testing_config_contents
+
+
+@pytest.mark.parametrize(
+    "set_config_key,get_config_key,expected_value",
+    [
+        ("some_top_string", "some_top_string", "some_top_value"),
+        ("second.some_second_string", "second_some_second_string", "some_second_value"),
+        (
+            "second.some_second_list",
+            "second_some_second_list",
+            ["some", "second", "value"],
+        ),
+        (
+            "second.some_second_table",
+            "second_some_second_table",
+            {"first": ["some", "first", "value"]},
+        ),
+        (
+            "second.some_second_table_bools",
+            "second_some_second_table_bools",
+            {"bool": [True, False]},
+        ),
+    ],
+)
+def test_get_value_from_key(
+    set_config_key, get_config_key, expected_value, header, shared_datadir
+):
+    """
+    Test the following:
+
+    - keys are read from top level key
+    - keys are read from two level key
+    - inline arrays are read correctly
+    - inline tables are read correctly
+    - inline tables & arrays read bools correctly
+    """
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(config, set_config_key)
+
+    # act
+    config_value = getattr(config, get_config_key)
+
+    # assert
+    assert config_value == expected_value
+
+
+def test_get_value_environment_var_override(header, shared_datadir):
+    # arrange
+    os.environ[f"{header.upper()}_SOME_TOP_STRING"] = '"some_overridden_value"'
+    config_path = str(shared_datadir / "without_logging")
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(config, "some_top_string")
+
+    # act
+    config_value = getattr(config, "some_top_string")
+
+    # assert
+    assert config_value == "some_overridden_value"
+
+    # cleanup
+    del os.environ[f"{header.upper()}_SOME_TOP_STRING"]
+
+
+def test_key_level_too_deep(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+    config = panaetius.Config(header, config_path)
+    key = "a.key.too.deep"
+
+    # act
+    with pytest.raises(KeyErrorTooDeepException) as key_error_too_deep:
+        panaetius.set_config(config, key)
+
+    # assert
+    assert (
+        str(key_error_too_deep.value)
+        == f"Your key of {key} can only be 2 levels deep maximum. "
+        f"You have 4"
+    )
+
+
+def test_get_value_missing_key_from_default(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(
+        config,
+        "missing.key_from_default",
+        default=["some", "default", "value", 1.0, True],
+    )
+
+    # act
+    default_value = getattr(config, "missing_key_from_default")
+
+    # assert
+    assert default_value == ["some", "default", "value", 1.0, True]
+
+
+def test_get_value_missing_key_from_env(header, shared_datadir):
+    # arrange
+    os.environ[f"{header.upper()}_MISSING_KEY"] = '"some missing key"'
+
+    config_path = str(shared_datadir / "without_logging")
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(config, "missing_key")
+
+    # act
+    value_from_key = getattr(config, "missing_key")
+
+    # assert
+    assert value_from_key == "some missing key"
+
+    # cleanup
+    del os.environ[f"{header.upper()}_MISSING_KEY"]
+
+
+# test env vars
+
+
+def test_config_file_does_not_exist(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "nonexistent_folder")
+
+    # act
+    config = panaetius.Config(header, config_path)
+    config_contents = config.config
+
+    # assert
+    assert config._missing_config is True
+    assert config_contents == {}
+
+
+def test_missing_config_read_from_default(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "nonexistent_folder")
+
+    # act
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(config, "missing.key_read_from_default", default=True)
+
+    # assert
+    assert getattr(config, "missing_key_read_from_default") is True
+
+
+@pytest.mark.parametrize(
+    "env_value,expected_value",
+    [
+        ('"a missing string"', "a missing string"),
+        ("1", 1),
+        ("1.0", 1.0),
+        ("True", True),
+        (
+            '["an", "array", "of", "items", 1, True]',
+            ["an", "array", "of", "items", 1, True],
+        ),
+        (
+            '{"an": "array", "of": "items", "1": True}',
+            {"an": "array", "of": "items", "1": True},
+        ),
+    ],
+)
+def test_missing_config_read_from_env_var(
+    env_value, expected_value, header, shared_datadir
+):
+    # arrange
+    config_path = str(shared_datadir / str(uuid4()))
+    os.environ[f"{header.upper()}_MISSING_KEY_READ_FROM_ENV_VAR"] = env_value
+
+    # act
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(config, "missing.key_read_from_env_var")
+
+    # assert
+    assert getattr(config, "missing_key_read_from_env_var") == expected_value
+
+    # cleanup
+    del os.environ[f"{header.upper()}_MISSING_KEY_READ_FROM_ENV_VAR"]
+
+
+def test_missing_config_read_from_env_var_invalid_python(header):
+    # arrange
+    os.environ[f"{header.upper()}_INVALID_PYTHON"] = "a string without quotes"
+    config = panaetius.Config(header)
+
+    # act
+    with pytest.raises(InvalidPythonException) as invalid_python_exception:
+        panaetius.set_config(config, "invalid_python")
+
+    # assert
+    assert (
+        str(invalid_python_exception.value)
+        == "a string without quotes is not valid Python."
+    )
+
+    # cleanup
+    del os.environ[f"{header.upper()}_INVALID_PYTHON"]

tests/test_library.py

@@ -0,0 +1,13 @@
+import panaetius
+
+
+def test_set_config(header, shared_datadir):
+    # arrange
+    config_path = str(shared_datadir / "without_logging")
+
+    # act
+    config = panaetius.Config(header, config_path)
+    panaetius.set_config(config, "some_top_string")
+
+    # assert
+    assert getattr(config, "some_top_string") == "some_top_value"

tests/test_logging.py

@@ -0,0 +1,34 @@
+import logging
+from uuid import uuid4
+
+import pytest
+
+from panaetius import set_logger, SimpleLogger, Config, set_config
+from panaetius.exceptions import LoggingDirectoryDoesNotExistException
+
+
+def test_logging_directory_does_not_exist(header, shared_datadir):
+    # arrange
+    config = Config(header)
+    logging_path = str(shared_datadir / str(uuid4()))
+    set_config(config, "logging.path", default=str(logging_path))
+
+    # act
+    with pytest.raises(LoggingDirectoryDoesNotExistException) as logging_exception:
+        _ = set_logger(config, SimpleLogger())
+
+    # assert
+    assert str(logging_exception.value) == ""
+
+
+def test_logging_directory_does_exist(header, shared_datadir):
+    # arrange
+    config = Config(header)
+    logging_path = str(shared_datadir / "without_logging")
+    set_config(config, "logging.path", default=str(logging_path))
+
+    # act
+    logger = set_logger(config, SimpleLogger())
+
+    # assert
+    assert isinstance(logger, logging.Logger)

tests/test_panaetius.py

@@ -1,5 +0,0 @@
-from panaetius import __version__
-
-
-def test_version():
-    assert __version__ == '0.1.0'