def __init__(self):
"""
Initialize a new Config instance
"""
self.dirs = AppDirs('MangaDL', 'Makoto')
# Internal file and ConfigParser placeholders
self._app_cfgfile = None
self._app_config = ConfigParser(interpolation=ExtendedInterpolation())
# Set the path information
self.app_config_dir = self.dirs.user_config_dir
self.app_config_file = "manga-dl.cfg"
self.app_config_path = path.join(self.app_config_dir,
self.app_config_file)
def parse_configuration_file(self, modelFileName):
config = ConfigParser(interpolation=ExtendedInterpolation())
config.optionxform = str
config.read(modelFileName)
# sections in configuration file
self.allSections = config.sections()
# read all sections
for section in self.allSections:
vars(self)[section] = {}
options = config.options(section)
for option in options:
val = config.get(section, option)
self.__getattribute__(section)[option] = val
def set_session(options, cookies, source):
print_debug(options, cookies)
config_file = options.get('config')
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(config_file)
if 'fofa' in source:
config.set('Cookies', 'fofa', cookies)
if 'shodan' in source:
config.set('Cookies', 'shodan', cookies)
if 'censys' in source:
config.set('Cookies', 'censys', cookies)
with open(config_file, 'w') as configfile:
config.write(configfile)
def get_config_var(sec, var):
try:
path_config = get_app_dir()+"/haproxy-webintarface.config"
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(path_config)
except:
print('Content-type: text/html\n')
print('<center><div class="alert alert-danger">Check the config file, whether it exists and the path. Must be: app/haproxy-webintarface.config</div>')
try:
var = config.get(sec, var)
return var
except:
print('Content-type: text/html\n')
print('<center><div class="alert alert-danger">Check the config file. Presence section %s and parameter %s</div>' % (sec, var))
def __init__(self,
defaults_file=os.path.join('config', 'defaults.cfg'),
config_file='',
**kwargs):
""""""
#super(Config, self).__init__(defaults=kwargs.pop('DEFAULT', {}))
super(Config, self).__init__(interpolation=ExtendedInterpolation())
self.read([defaults_file, config_file])
for section, options in six.iteritems(kwargs):
if section != 'DEFAULT' and not self.has_section(section):
self.add_section(section)
for option, value in six.iteritems(options):
self.set(section, option, str(value))
return
def load_config(filename):
"""Load the parameter configuration file.
Parameters:
filename (str): YSO configuration file name.
"""
# Verify file
name = os.path.realpath(os.path.expanduser(filename))
assert os.path.isfile(name)
# Load file
parser = myConfigParser(interpolation=ExtendedInterpolation())
parser.read(name)
return parser
def parse(cfile=None):
"""
Instantiates parser for INI (config) file
:param cfile: absolute filepath to config INI file
:return: ConfigParser object with configurations loaded
"""
if not cfile:
dir_path = os.path.dirname(os.path.realpath(__file__))
cfile = os.path.join(dir_path, "my_bb_configs.ini")
print("Loading configs: " + cfile)
parser = ConfigParser(interpolation=ExtendedInterpolation())
parser.read(cfile)
return parser
def read_position(self, typology, key, Locale):
file = self.cfg['REFERENCIAL']['referencialposition'] + str(
typology) + '.ini'
res = {}
if os.path.isfile(file):
parser = ConfigParser(interpolation=ExtendedInterpolation())
parser.read(file)
for section in parser.sections():
if section == key:
for info in parser[section]:
res[info] = parser[section][info]
if res and res['regex']:
localeList = Locale.get()
res['regex'] = localeList[res['regex']]
return res
def parseConfig(file):
"""
Parses the config file. The file must be of ini format.
If the file exists but is empty and exception will be generated.
:param file: The path of the file to parse
:return: Return a config object
"""
# make sure the file is not empty
size = Path(file).stat().st_size
if size != 0:
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(file.__str__())
return config
else:
raise Exception('File is empty.')
def readTestbenchConfiguration(self):
from configparser import ConfigParser, ExtendedInterpolation
tbConfigFilePath = self.directories["PoCRoot"] / self.pocConfig['PoC.DirectoryNames']['TestbenchFiles'] / self.__tbConfigFileName
self.files["PoCTBConfig"] = tbConfigFilePath
self.printDebug("Reading testbench configuration from '%s'" % str(tbConfigFilePath))
if not tbConfigFilePath.exists(): raise NotConfiguredException("PoC testbench configuration file does not exist. (%s)" % str(tbConfigFilePath))
self.tbConfig = ConfigParser(interpolation=ExtendedInterpolation())
self.tbConfig.optionxform = str
self.tbConfig.read([
str(self.files["PoCPrivateConfig"]),
str(self.files["PoCPublicConfig"]),
str(self.files["PoCTBConfig"])
])
def get_config(path):
"""
Return config variables
:param path(String): path to config file
:return configparser: user settings
:return configparser: developer settings
"""
config = configparser.ConfigParser(interpolation=ExtendedInterpolation())
config.read(path)
config_user = config['user_settings']
config_dev = config['developer_settings']
return config_user, config_dev
def __init__(self, config_file):
InstallationComponent.__init__(self)
ConfigParser.__init__(self,
interpolation=ExtendedInterpolation(),
allow_no_value=True)
self.optionxform = str # preserves case-sensitivity
config_dir = os.path.dirname(config_file)
credentials_file = os.path.join(config_dir, Config.CREDENTIALS_FILE)
if not os.path.exists(credentials_file):
self.raise_exception(
f'The file with credentials: {credentials_file} '
f"does not exist")
self.read([credentials_file, config_file])
def get_config_var(sec, var):
from configparser import ConfigParser, ExtendedInterpolation
try:
path_config = "/opt/smon/smon.cfg"
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(path_config)
except:
logger.fatal(
'Check the config file, whether it exists and the path. Must be: /opt/smon/smon.cfg'
)
try:
return config.get(sec, var)
except:
logger.fatal(
'Check the config file. Presence section %s and parameter %s' %
(sec, var))
def create_config(options):
cfg = ConfigParser(interpolation=ExtendedInterpolation())
conf_path = os.path.join(dataPath, 'dscan.conf')
if options.config:
conf_path = os.path.join(options.name, options.config)
data = open(conf_path)
cfg.read_file(data)
data.close()
config = Config(cfg, options)
handler = logging.FileHandler(os.path.join(args.name, f"drecon-{now}.log"))
handler.setFormatter(logging.Formatter(FORMAT))
log = logging.getLogger()
log.addHandler(handler)
log.setLevel(logging.DEBUG)
return config
def __init__(self, config_override_filename=None):
"""Load the configuration (usually config.ini)."""
if config_override_filename and not os.path.isfile(
config_override_filename):
raise ValueError("Unable to find config file {}".format(
config_override_filename))
main_file = os.path.join(get_dir('codebase'), 'config.ini')
self.config = ConfigParser(interpolation=ExtendedInterpolation())
self.config.optionxform = str # enforce case sensitivity on key
if config_override_filename: # custom config
self.config.read([main_file, config_override_filename])
else: # no custom file
self.config.read(main_file)
def _read(self, config_file=None):
"""
Reads config_file and returns a configparser object of it
:param config_file:
:return config:
"""
config_file = config_file if config_file is not None else self.config_file
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(config_file)
if not config.sections():
self._create()
return config
def __init__(self, config_path):
assert os.path.exists(config_path), '{} not exists.'.format(config_path)
self.config = ConfigParser(
delimiters='=',
interpolation=ExtendedInterpolation())
self.config.read(config_path)
try:
self.lambda1_stud = self.config.getfloat('stud', 'lambda1_stud')
except:
logger.warning('lambda1_stud not found in config file')
self.lambda1_stud = 0
try:
self.lambda2_stud = self.config.getfloat('stud', 'lambda2_stud')
except:
logger.warning('lambda2_stud not found in config file')
self.lambda2_stud = 0
def get_curr_feedback(self):
uomid = self.utility.get_uomid_of_current_dir()
if uomid == -1:
print('Error: You have to be in a student directory')
else:
try:
log_path = self.feedback_dir + '/' + self.FEEDBACK_LOG_NAME
parser = ConfigParser(interpolation=ExtendedInterpolation())
parser.read(log_path)
for option in parser[uomid]:
print(option + ' : ' + parser.get(uomid, option))
except:
print('You currently have not assigned any feedback')
pass
def __init__(self, filename, overrides=None):
self._parser = ConfigParser(interpolation=ExtendedInterpolation(),
allow_no_value=True)
self.filename = filename
self.sections = []
with open(self.filename) as fhandle:
data = expand_env_vars(fhandle.read().strip())
# Read the defaults first
self._parser.read_dict({'train': TRAIN_DEFAULTS})
# Read the config
self._parser.read_string(data)
if overrides is not None:
# ex: train.batch_size:32
self.overrides = self.parse_overrides(overrides)
for section in self._parser.sections():
opts = {}
self.sections.append(section)
for key, value in self._parser[section].items():
opts[key] = resolve_path(_parse_value(value))
if section in self.overrides:
for (key, value) in self.overrides[section].items():
opts[key] = value
setattr(self, section, opts)
# Sanity check for [train]
train_keys = list(self.train.keys())
def_keys = list(TRAIN_DEFAULTS.keys())
assert len(train_keys) == len(set(train_keys)), \
"Duplicate arguments found in config's [train] section."
invalid_keys = set(train_keys).difference(set(TRAIN_DEFAULTS))
for key in invalid_keys:
match = get_close_matches(key, def_keys, n=1)
msg = "{}:train: Unknown option '{}'.".format(self.filename, key)
if match:
msg += " Did you mean '{}' ?".format(match[0])
print(msg)
if invalid_keys:
sys.exit(1)
def quoteWatchInit():
print("in quoteWatchInit\r\n")
#cfg = ConfigParser()
cfg = ConfigParser(interpolation=ExtendedInterpolation())
try:
cfg.read('./config.ini')
cfg.sections()
#cfgSet.api_key = str(cfg.get('Unity','api_key'))
#cfgSet.seceret_key = str(cfg.get('Unity','seceret_key'))
#cfgSet.passphrase = str(cfg.get('Unity','passphrase'))
#log.info(cfgSet.api_key+","+cfgSet.seceret_key+","+cfgSet.passphrase)
cfgSet.phoneKey = str(cfg.get('Unity', 'phoneKey'))
log.info(cfgSet.phoneKey)
cfgSet.phone = cfg.get('Unity', 'phone')
log.info(str(cfgSet.phone))
cfgSet.symbol1 = str(cfg.get('pair1', 'symbol'))
cfgSet.priceHigh1 = cfg.getfloat('pair1', 'priceHigh')
cfgSet.priceLow1 = cfg.getfloat('pair1', 'priceLow')
log.info("pair1: " + str(cfgSet.symbol1) + " " +
str(cfgSet.priceHigh1) + " " + str(cfgSet.priceLow1))
print(("pair1: " + str(cfgSet.symbol1) + " " + str(cfgSet.priceHigh1) +
" " + str(cfgSet.priceLow1)))
cfgSet.symbol2 = str(cfg.get('pair2', 'symbol'))
cfgSet.priceHigh2 = cfg.getfloat('pair2', 'priceHigh')
cfgSet.priceLow2 = cfg.getfloat('pair2', 'priceLow')
log.info("pair2: " + str(cfgSet.symbol2) + " " +
str(cfgSet.priceHigh2) + " " + str(cfgSet.priceLow2))
cfgSet.symbol3 = str(cfg.get('pair3', 'symbol'))
cfgSet.priceHigh3 = cfg.getfloat('pair3', 'priceHigh')
cfgSet.priceLow3 = cfg.getfloat('pair3', 'priceLow')
log.info("pair3: " + str(cfgSet.symbol3) + " " +
str(cfgSet.priceHigh3) + " " + str(cfgSet.priceLow3))
cfgSet.symbol4 = str(cfg.get('pair4', 'symbol'))
cfgSet.priceHigh4 = cfg.getfloat('pair4', 'priceHigh')
cfgSet.priceLow4 = cfg.getfloat('pair4', 'priceLow')
log.info("pair4: " + str(cfgSet.symbol4) + " " +
str(cfgSet.priceHigh4) + " " + str(cfgSet.priceLow4))
except Exception as e:
log.error("config error ", str(e))
print("config error ", str(e))
class ResourceLinks(BetterLogger):
audio: PathConfigParser = PathConfigParser(
interpolation=ExtendedInterpolation())
font: PathConfigParser = PathConfigParser(
interpolation=ExtendedInterpolation())
language: PathConfigParser = PathConfigParser(
interpolation=ExtendedInterpolation())
texture: PathConfigParser = PathConfigParser(
interpolation=ExtendedInterpolation())
model: PathConfigParser = PathConfigParser(
interpolation=ExtendedInterpolation())
gameConfig: PathConfigParser = PathConfigParser(
interpolation=ExtendedInterpolation())
audio_file_name: str = "audioLink.ini"
font_file_name: str = "fontLink.ini"
language_file_name: str = "langLink.ini"
texture_file_name: str = "textureLink.ini"
model_file_name: str = "modelLink.ini"
game_data_file_name: str = "gameConfigLink.ini"
array: {
str: PathConfigParser
} = {
"audio": audio,
"font": font,
"language": language,
"texture": texture,
"model": model,
"gameConfig": gameConfig
}
def __init__(self, *args, **kwargs):
BetterLogger.__init__(self, *args, **kwargs)
self.audio.__log_name_prefix__ = "Audio_"
self.font.__log_name_prefix__ = "Font_"
self.language.__log_name_prefix__ = "Language_"
self.texture.__log_name_prefix__ = "Textures_"
self.model.__log_name_prefix__ = "Models_"
self.gameConfig.__log_name_prefix__ = "GameConfig_"
def load_link_files(self):
self.log_debug("Loading link files")
self.audio.read(os.path.join(resources_dir, self.audio_file_name))
self.font.read(os.path.join(resources_dir, self.font_file_name))
self.language.read(os.path.join(resources_dir,
self.language_file_name))
self.texture.read(os.path.join(resources_dir, self.texture_file_name))
self.model.read(os.path.join(resources_dir, self.model_file_name))
self.gameConfig.read(
os.path.join(resources_dir, self.game_data_file_name))
self.log_info("Loaded link files")
def __init__(self, section):
self._config = ConfigParser(interpolation=ExtendedInterpolation())
self._section = section
# Potential config files
LOCATIONS = [
'/etc/griotte.ini', '/usr/local/etc/griotte.ini',
os.path.expanduser("~") + '/.griotte.ini'
]
for file in LOCATIONS:
if os.path.exists(file):
logging.info("reading config file %s" % file)
self._config.read_file(open(file))
self._translate_to_tornado()
options.parse_command_line()
def __init__(self):
path_module = 'path'
file_module = 'file'
model_module = 'filter model'
file_dir = os.path.abspath(os.path.dirname(__file__))
# file_dir = os.path.split(os.path.realpath(__file__))[0]
config_file_name = os.path.join(file_dir, 'conf.ini')
configreader = ConfigParser(interpolation=ExtendedInterpolation())
configreader.read(config_file_name)
# path
self.data_path = configreader.get(path_module, 'data_path')
self.origin_path = configreader.get(path_module, 'origin_path')
self.autophrase_path = configreader.get(path_module, 'autophrase_path')
self.ner_service_command = configreader.get(path_module,
'ner_service_command')
# self.ark_service_command = configreader.get(path_module, 'ark_service_command')
# self.ark_service_command = '/home/nfs/cdong/tw/src/tools/ark-tweet-nlp-0.3.2.jar'
# files
self.pre_dict_file = configreader.get(file_module, 'pre_dict_file')
self.post_dict_file = configreader.get(file_module, 'post_dict_file')
# files
self.afinn_file = configreader.get(model_module, 'afinn_file')
self.black_list_file = configreader.get(model_module,
'black_list_file')
self.clf_model_file = configreader.get(model_module, 'clf_model_file')
self.class_dist_file = configreader.get(model_module,
'class_dist_file')
self.chat_filter_file = configreader.get(model_module,
'chat_filter_file')
self.is_noise_dict_file = configreader.get(model_module,
'is_noise_dict_file')
self.orgn_predict_label_file = configreader.get(
model_module, 'orgn_predict_label_file')
self.terror_ft_model_file = configreader.get(model_module,
'terror_ft_model_file')
self.terror_lr_model_file = configreader.get(model_module,
'terror_lr_model_file')
self.korea_ft_model_file = configreader.get(model_module,
'korea_ft_model_fiel')
def run(_cfg,source_data=None):
cfg = ConfigParser(interpolation=ExtendedInterpolation())
cfg.read(_cfg)
left = aux.read.into_list(cfg['mat']['left_nodes'])
right = aux.read.into_list(cfg['mat']['right_nodes'])
data = []
add_data(cfg,data,['all','all'])
add_data(cfg,data,['all','low'],edge_filter=low_pass_edge_filter,args=35)
add_data(cfg,data,['all','mid'],edge_filter=mid_pass_edge_filter,args=(35,66))
add_data(cfg,data,['all','high'],edge_filter=high_pass_edge_filter,args=66)
add_data(cfg,data,['ipsilateral','all'],edge_filter=ipsilateral_pass_filter,args=[left,right])
add_data(cfg,data,['contralateral','all'],edge_filter=contralateral_pass_filter,args=[left,right])
df = pd.DataFrame(data,columns=["Comparison","Network","Edge threshold","Measure","Cell","Jaccard Distance"])
if source_data: df.to_csv(source_data,index=False)
def __init__(self, xl_name="data_obj_cfg"):
"""
Initialize ParametersParser
Looks for Excel named range xl_name that contains ParametersParser object
Parameters
----------
xl_name
"""
self.xl: w32 = xl_app()
self.xl_name = xl_name
self._log = logging.getLogger(__name__)
ConfigParser.__init__(self, interpolation=ExtendedInterpolation())
self._log.info(f"{__class__.__name__}({len(self)} groups)")
def __init__(self, filename=None, *, string="", obj=None, mapping=None):
self.cfg = ConfigParser(interpolation=ExtendedInterpolation())
if filename:
self.filename = filename
self.cfg.read(self.filename)
elif string:
self.filename = "_string.ini"
self.cfg.read_string(string, self.filename)
elif obj:
self.filename = "_fileobj.ini"
self.cfg.read_file(string, self.filename)
elif mapping:
self.filename = "_mapping.ini"
self.cfg.read_dict(mapping, self.filename)
else:
self.filename = "_default.ini"
self.cfg.read_string(DEFAULT_CONFIG, self.filename)
def treat_common_args(args):
if args.version:
sys.exit(0)
parser = ConfigParser(interpolation=ExtendedInterpolation())
variables.config = copy.deepcopy(defaultconfig)
variables.loader = LoaderClass()
# Read actual config file
parser.read(args.config)
variables.configfile = parser
arg = vars(args)
update_conf(arg, "common")
# logconf = variables.config["common"]['logconfigfile']
if os.path.isfile(args.logconfigfile):
logging.config.fileConfig(args.logconfigfile,
disable_existing_loggers=False)
def get_cred(options, source):
config_file = options.get('config')
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(config_file)
if 'fofa' in source:
cred = config.get('Credentials', 'fofa')
if 'shodan' in source:
cred = config.get('Credentials', 'shodan')
if 'censys' in source:
cred = config.get('Credentials', 'censys')
print_debug(options, cred)
username = cred.split(':')[0].strip()
password = cred.split(':')[1].strip()
return username, password
def init(self, filename: str = None) -> bool:
defaults = {
CLEANUP: 'automatic',
ENABLED: 'false',
INTEGRITY_CHECK: 'sha256',
LOG_LEVEL: 'WARNING',
LOG_METHOD: 'console',
MAX_SIZE: '10MB',
}
self.parser = ConfigParser(defaults=defaults,
interpolation=ExtendedInterpolation())
for dict_ in [malwarepatrol, sanesecurity, securiteinfo, urlhaus]:
self.parser.read_dict(dict_)
if filename:
parsed = self.parser.read([filename])
return len(parsed) == 1
return True
def __load_ini_file(file_path):
"""
This method will load key-value pairs store in ini file and stores them in configuration manager.
Args:
file_path(str): Path of ini file.
Returns:
None
"""
config = ConfigParser(interpolation=ExtendedInterpolation())
config.read(file_path)
for each_section in config.sections():
for key, value in config.items(each_section):
ConfigurationsManager().set_object_for_key(key=key,
value=value)
