config-manager-evjeny 0.3.0

Small config manager for parsing configs from different sources

config_manager

Configuration manager for parsing from different sources

Installation

python -m pip install config-manager-evjeny

Usage

Create class with config variables and inherit it from config_manager.config.Config. You can define variables and their types or even define values. Then we can parse variables from different sources. For example, this is example_parser.py:

from config_manager.config import Config
from config_manager.variable_parsers import ListType


class TestConfig(Config):
    """Config example with some variables of different types"""

    name: str
    age: int
    is_useful: bool = False
    parts: ListType[float]


my_config = TestConfig() \
    .parse_env(prefix="test_config_") \
    .parse_json(json_path="test_config.json") \
    .parse_arguments("TestConfig parser")

print(my_config)

If we run it:

test_config_age=33 python example_parser.py \
  --name hello \
  --is_useful false \
  --parts "[0.25, 0.5, 0.75]"

It will output something like and all the primitive types will be parsed correctly:

age = 33
is_useful = False
name = hello
parts = [0.25, 0.5, 0.75]

Type details

str, int and float

For str, int and float casting is the same as builtin functions.

bool

Generally all not empty containers (even string "false") cast to bool would return True.

Thus, there is a BoolParser that casts value to True in one of these cases:

• variable is subclass of str and it's value one of (in any case):
  • "yes"
  • "true"
  • "1"
  • "on"
• in other cases default bool call used

from config_manager.variable_parsers import BoolParser

parser = BoolParser()

assert parser("yes") == True
assert parser("yES") == True
assert parser("tRuE") == True
assert parser("1") == True
assert parser("on") == True

assert parser("no") == False
assert parser("FaLsE") == False

assert parser(1.0) == True
assert parser(0.0) == False
assert parser(1) == True
assert parser(0) == False
assert parser(True) == True
assert parser(False) == False

ListType

As it is impossible to get type from typing.List[T] (plus this annotation removed in Python 3.9) there is a ListType. It can be used with any parseable type, so every element will be cast to target type. For example:

from config_manager.variable_parsers import ListType

# shallow lists
assert ListType[int](["1", "2", "3"]) == [1, 2, 3]
assert ListType[str]([1.0, -213.5122, 52.123]) == ["1.0", "-213.5122", "52.123"]
assert ListType[int]("[1, 2, 3]") == [1, 2, 3]

All the parse sources provide different ways to define list, so there they are:

• in predefine and json case simply assign any python list to variable
• in environment and argument cases every list is parsed from string [item_1, item_2, ...]