def test_required_access(path):
builder = ConfigBuilder()
builder.set_field_access_required()
builder.add_optional_field("server.nokey")
builder.add_optional_fields(["cache.name", "test"])
config = builder.parse_config(path)
assert config.test is None
with pytest.raises(AttributeError):
config.nokey
assert config.server.nokey is None
with pytest.raises(AttributeError):
config.server.nokey2
assert config.cache.name is None
with pytest.raises(AttributeError):
config.cache.name2
def loadConfigFromFile(path) -> 'Config':
def makeElement(x: int, y: int, c: typing.TypeVar(T), grid_size: int):
return c(Point(x, y), grid_size)
builder = ConfigBuilder()
config = builder.parse_config(path)
builder.set_field_access_required()
builder.add_required_field(GRID_CONFIG)
builder.add_required_field(MAX_ITER)
builder.add_required_field(DEFAULT_CONFIG)
builder.add_required_field(DISINTEGRATE_PROB_CONFIG)
builder.validate_field_type(GRID_CONFIG, int)
builder.validate_field_type(MAX_ITER, int)
builder.validate_field_type(DEFAULT_CONFIG, str)
builder.validate_field_type(HOLES_CONFIG, [(int, int)])
builder.validate_field_type(SUBSTRATES_CONFIG, [(int, int)])
builder.validate_field_type(CATALYSTS_CONFIG, [(int, int)])
builder.validate_field_type(LINKS_CONFIG, [(int, int)])
builder.validate_field_type(DISINTEGRATE_PROB_CONFIG, float)
# set up
grid_size = config.grid_size
default_element: T = STR_TO_CLASS[config.default]
iter = config.max_iter
disint_prob = config.disintegration_probability
h_plist = [
makeElement(x, y, Hole, grid_size)
for x, y in list(ast.literal_eval(config.Holes))
] if config.Holes else []
s_plist = [
makeElement(x, y, Substrate, grid_size)
for x, y in list(ast.literal_eval(config.Substrates))
] if config.Substrates else []
k_plist = [
makeElement(x, y, Catalyst, grid_size)
for x, y in list(ast.literal_eval(config.Catalysts))
] if config.Catalysts else []
l_plist = [
makeElement(x, y, Link, grid_size)
for x, y in list(ast.literal_eval(config.Links))
] if config.Links else []
return Config(grid_size, default_element, iter, h_plist, s_plist,
k_plist, l_plist, disint_prob)
from python_json_config import ConfigBuilder
# create config_util parser
builder = ConfigBuilder()
builder.set_field_access_required()
# parse config_util
config = builder.parse_config('config.json')
class Configuration:
config_url = None
io = None
builder = None
config = None
is_valid = None
def __init__(self, config_url):
self.config_url = config_url
self.builder = ConfigBuilder()
self.io = DirectConsoleIo()
#add the required fields
self.builder.set_field_access_required()
self.builder.add_required_field('logging')
self.builder.add_required_field('logging.writers')
self.builder.add_required_field('database')
self.builder.add_required_fields('database.db_url')
self.builder.add_required_field('ticker_data_source')
self.builder.add_required_field('ticker_data_source.source')
self.builder.add_required_fields('plugins')
def load_configuration(self):
try:
if not self.is_config_url_valid():
self.configuration_error("Configuration file not found")
return False
self.config = self.builder.parse_config(self.config_url)
if not self.validate_configuration():
return False
else:
self.io.info("Configuration loaded")
return True
except Exception as e:
self.configuration_error(e)
def is_config_url_valid(self):
try:
return path.exists(self.config_url)
except Exception as e:
self.configuration_error(e)
def configuration_error(self, e):
self.is_valid = False
self.io.error("Loading configuration file.")
self.io.error(e)
def get_logging_config(self):
return self.config.logging.writers
def get_plugin_config(self):
return self.config.plugins
def get_plugin_args(self):
return self.config.args
def validate_configuration(self):
try:
self.config.logging
self.config.logging.writers
self.config.database
self.config.database.db_url
self.config.plugins
return True
except Exception as e:
self.io.error("Error validating configuration file ")
self.io.error(e)
def get_plugin_args_by_name(self, name):
if name in self.get_plugin_args().to_dict().keys():
args = []
index = list(self.get_plugin_args().to_dict().keys()).index(name)
self.io.debug("index {}".format(index))
vals = list(self.get_plugin_args().to_dict().values())
self.io.debug(vals[index])
return vals[index]
else:
self.io.error(
"plugin configuration not found for : {}".format(name))
return -1
