Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_falls_back_when_there_is_config_error(self, mock_log):
self.mock_parser.side_effect = configparser.Error()
open_config_file('gtg.conf')
self.mock_parser.assert_called_once_with('gtg.conf')
self.assertTrue(mock_log.warning.called)
def _loadsettings(filename,parent=None):
sectiondicts={}
sections={}
values={}
config = configparser.ConfigParser(interpolation=None,empty_lines_in_values=False,default_section="~#'[&INVALID&]'#~",dict_type=dict)
try:
with open(filename,'r') as f:
config.read_file(f)
except FileNotFoundError as ex:
if parent is None:
raise ex
else:
return parent
except configparser.Error as ex:
print("Error reading config file")
print(ex)
if parent is None:
raise ex
else:
return parent
for sectionname in config.sections():
sectiondict=sectiondicts
section=sections
value=values
for el in sectionname.split("."):
if el not in sectiondict:
newsections={}
newvalues={}
sectiondict[el]=({},newsections,newvalues)
section[el]=SettingsSection(newsections,newvalues)
def init(app, config_file):
global metadata
config = topicexplorer.config.read(config_file)
try:
filename = config.get('bibtex', 'path')
except ConfigParserError:
model_path = config.get('main', 'path')
filename = os.path.join(model_path, 'library.bib')
print("Loading Bibtex metadata from", filename)
bib = parse_file(filename)
metadata = dict()
for entry in bib.entries:
key = '/' + bib.entries[entry].fields.get('file', '').replace(':pdf', '')[1:]
if 'C$\\backslash$:' in key:
key = key.replace('C$\\backslash$:', '')
key = key[1:]
key = os.path.normpath(key)
key = os.path.basename(key)
try:
citation = pybtex.format_from_file(
def get_config_value(section, option, default):
scp = configparser.SafeConfigParser()
scp.read(CONFIG_FILENAME)
try:
return scp.get(section, option)
except configparser.Error:
return default
def parse_desktop_file(self, pkg, root, f, filename):
"""
Check the structure of a desktop file.
"""
cfp = cfgparser.RawConfigParser()
try:
with codecs.open(f, encoding='utf-8') as inputf:
cfp.read_file(inputf, filename)
except cfgparser.Error as e:
self._handle_parser_error(pkg, filename, e)
except UnicodeDecodeError as e:
self.output.add_info('E', pkg, 'non-utf8-desktopfile', filename, f'Unicode error: {e}')
else:
self._has_binary(pkg, root, cfp, filename)
def parse(self, cfg_set, creator, logger, args=None):
cfg = configparser.ConfigParser()
cfg.optionxform = str # do not case convert
# read config
try:
if self.fobj is not None:
cfg.readfp(self.fobj, self.cfg_file)
else:
with open(self.cfg_file) as fh:
cfg.readfp(fh, self.cfg_file)
logger.info("%s: config read", self.cfg_file)
except configparser.Error as e:
logger.error("%s: failed parsing: %s", self.cfg_file, e)
return False
# run through sections
for sect in cfg.sections():
for opt in cfg.options(sect):
in_val = cfg.get(sect, opt)
if not self._parse_sect_opt(cfg_set, creator, logger,
sect, opt, in_val):
return False
return True
# Sanity check: All devices must point at a vendor object.
# Side effect: build the lists of vendors and devices.
self.vendors = []
self.devices = []
for section in self.sections():
if self.get(section, "type") == "vendor":
self.vendors.append(section)
if self.get(section, "type") == "device":
self.devices.append(section)
self.vendors.sort()
for section in self.sections():
if self.get(section, "type") == "device":
if not self.has_option(section, "vendor"):
raise configparser.Error("%s has no vendor" % section)
if self.get(section, "vendor") not in self.vendors:
raise configparser.Error("%s has invalid vendor" % section)
def load(self):
try:
self._config_parser.read(self._config_file)
except configparser.Error as e:
applet_log.warning("CONFIG: malformed configuration file, using default [%s]" % e)
self._default()
self.save()
parser.read_file(fp)
config['lastrun'] = parser.get(GEN,'lastrun')
config['format'] = parser.get(GEN,'format')
config['duplicates'] = parser.getboolean(GEN,'duplicates')
config[ENG] = {}
for engine_name in ENGINES.keys():
engine_section = {}
error = None
try:
engine_section['state'] = parser.getboolean(engine_name, 'state')
engine_section['tags'] = parser.get(engine_name,'tags')
engine_section['blacklist'] = parser.get(engine_name,'blacklist')
except (configparser.Error) as e:
error = str(e)
except KeyError as e:
error = "section [{}] not found in config file".format(e)
except ValueError as e:
error = 'error processing section [{}]: {}'.format(engine_name, e)
else:
LOG.debug('successfully parsed [%s] section in %s', engine_name, DEFAULT_INI_NAME)
config[ENG][engine_name] = engine_section
if error:
LOG.error(error)
error_str = "problem parsing [{}], this engine will be skipped.".format(engine_name)
return config
log_directory = os.path.join(data_dir, 'steam_tools_ng')
new("logger", "log_directory", log_directory)
log_level = parser.get("logger", "log_level")
if log_level and not log_level.upper() in log_levels:
raise configparser.Error(
_("Please, fix your config file. Accepted values for log_level are:\n{}").format(
', '.join(log_levels),
)
)
log_console_level = parser.get("logger", "log_console_level")
if log_console_level and not log_console_level.upper() in log_levels:
raise configparser.Error(
_("Please, fix your config file. Accepted values for log_console_level are:\n{}").format(
', '.join(log_levels),
)
)
os.makedirs(log_directory, exist_ok=True)