def main():
parser = argparse.ArgumentParser(description="Blinktrade WebSocket Gateway application")
parser.add_argument('-i', "--instance", action="store", dest="instance", help='Instance name', type=str)
parser.add_argument('-c', "--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/bitex.ini'),
help='Configuration file', type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [ os.path.join(site_config_dir('blinktrade'), 'bitex.ini'),
os.path.expanduser('~/.blinktrade/bitex.ini'),
arguments.config]
config = ConfigParser.SafeConfigParser()
config.read( candidates )
options = ProjectOptions(config, arguments.instance)
if not options.trade_in or\
not options.trade_pub or\
not options.gateway_log or\
not options.callback_url or\
not options.port or\
not options.allowed_origins or\
not options.sqlalchemy_connection_string or \
not options.sqlalchemy_engine:
raise RuntimeError("Invalid configuration file")
run_application(options, arguments.instance)
def main():
parser = argparse.ArgumentParser(description="Blinktrade WebSocket Gateway application")
parser.add_argument('-i', "--instance", action="store", dest="instance", help='Instance name', type=str)
parser.add_argument('-c', "--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/bitex.ini'),
help='Configuration file', type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [ os.path.join(site_config_dir('blinktrade'), 'bitex.ini'),
os.path.expanduser('~/.blinktrade/bitex.ini'),
arguments.config]
config = ConfigParser.SafeConfigParser()
config.read( candidates )
options = ProjectOptions(config, arguments.instance)
if not options.trade_in or\
not options.trade_pub or\
not options.gateway_log or\
not options.callback_url or\
not options.port or\
not options.allowed_origins or\
not options.sqlalchemy_connection_string or \
not options.sqlalchemy_engine:
raise RuntimeError("Invalid configuration file")
run_application(options, arguments.instance)
def install_config():
def make_hier(path):
if path != '/':
make_hier(os.path.dirname(path))
if not os.path.exists(path):
os.mkdir(path)
dst_base = appdirs.site_config_dir('prompter')
make_hier(dst_base)
src_base = os.path.join(prompter_path, 'default')
for src_path, dst_path, dirs, files in ((path, ''.join([
dst_base, path[len(src_base):]
]), dirs, files) for path, dirs, files in os.walk(src_base)):
if not os.path.exists(dst_path):
os.mkdir(dst_path)
for filename in files:
basename, ext = os.path.splitext(filename)
if ext.casefold() == '.yaml':
gz_filename = '.'.join([filename, 'gz'])
src_filepath = os.path.join(src_path, filename)
dst_filepath = os.path.join(dst_path, gz_filename)
if not os.path.exists(dst_filepath):
with open(src_filepath) as src, \
gzip.open(dst_filepath, 'wb') as dst:
dst.write(src.read())
def _find_config():
# prefer config file in the following order:
# 1) current directory, 2) user home directory, 3) bundled config
config_dirs = (
['.'] + [appdirs.user_config_dir("bandit")] +
appdirs.site_config_dir("bandit", multipath=True).split(':'))
if _running_under_virtualenv():
config_dirs.append(os.path.join(sys.prefix, 'etc', 'bandit'))
config_dirs.append(
os.path.join(sysconfig.get_paths().get('purelib', ''), 'bandit',
'config'))
config_locations = [os.path.join(s, BASE_CONFIG) for s in config_dirs]
# pip on Mac installs to the following path, but appdirs expects to
# follow Mac's BPFileSystem spec which doesn't include this path so
# we'll insert it. Issue raised as http://git.io/vOreU
mac_pip_cfg_path = "/usr/local/etc/bandit/bandit.yaml"
if mac_pip_cfg_path not in config_locations:
config_locations.append(mac_pip_cfg_path)
for config_file in config_locations:
if os.path.isfile(config_file):
return config_file # Found a valid config
else:
# Failed to find any config, raise an error.
raise utils.NoConfigFileFound(config_locations)
def default_config_directories(
user_config_dir=None,
system_config_dir=None,
exedir=None,
verbose=0):
# Use configuration in the order (lowest to highest priority)
# 1) same path as exe,
# 2) system config (XDG compliant. /etc/xdg/ct)
# 3) user config (XDG compliant. ~/.config/ct)
# 4) environment variables
# 5) given on the command line
# These variables are settable to assist writing tests
if user_config_dir is None:
user_config_dir = appdirs.user_config_dir(appname='ct')
if system_config_dir is None:
system_config_dir = appdirs.site_config_dir(appname='ct')
if exedir is None:
exedir = ct.wrappedos.dirname(ct.wrappedos.realpath(sys.argv[0]))
executable_config_dir = os.path.join(exedir, "ct.conf.d")
results = [user_config_dir, system_config_dir, executable_config_dir]
if verbose >= 9:
print(" ".join(["Default config directories"] + results))
return results
def main():
parser = argparse.ArgumentParser(description="Blinktrade Mailer application")
parser.add_argument('-i', "--instance", action="store", dest="instance", help='Instance name', type=str)
parser.add_argument('-c', "--config", action="store", dest="config", default=os.path.expanduser('~/.bitex/bitex.ini'), help='Configuration file', type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [ os.path.join(ROOT_PATH, 'config/bitex.ini'),
os.path.join(site_config_dir('bitex'), 'bitex.ini'),
arguments.config]
config = ConfigParser.SafeConfigParser()
config.read( candidates )
options = ProjectOptions(config, arguments.instance)
#if not options.mailchimp_apikey or\
# not options.mandrill_apikey or\
# not options.mailchimp_newsletter_list_id or\
# not options.trade_in or \
# not options.trade_pub or \
# not options.mailer_log :
# raise RuntimeError("Invalid configuration file")
run_application(options, arguments.instance)
def site_config_dir(self):
"""Return ``site_config_dir``."""
directory = appdirs.site_config_dir(self.appname, self.appauthor,
version=self.version, multipath=self.multipath)
if self.create:
self._ensure_directory_exists(directory)
return directory
def main():
parser = argparse.ArgumentParser(description="Blinktrade Fraud application")
parser.add_argument('-i', "--instance", action="store", dest="instance", help='Instance name', type=str)
parser.add_argument('-c', "--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/bitex.ini'),
help='Configuration file', type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [ os.path.join(site_config_dir('blinktrade'), 'bitex.ini'),
os.path.expanduser('~/.blinktrade/bitex.ini'),
arguments.config]
config = ConfigParser.SafeConfigParser()
config.read( candidates )
options = ProjectOptions(config, arguments.instance)
if not options.maxmind_license_key or\
not options.trade_in or\
not options.frauder_username or\
not options.frauder_password or\
not options.trade_pub or \
not options.app_log :
raise RuntimeError("Invalid configuration file")
run_application(options, arguments.instance)
def _find_config():
# prefer config file in the following order:
# 1) current directory, 2) user home directory, 3) bundled config
config_dirs = (
['.'] + [appdirs.user_config_dir("bandit")] +
appdirs.site_config_dir("bandit", multipath=True).split(':'))
if _running_under_virtualenv():
config_dirs.append(os.path.join(sys.prefix, 'etc', 'bandit'))
config_dirs.append(
os.path.join(sysconfig.get_paths().get('purelib', ''),
'bandit', 'config'))
config_locations = [os.path.join(s, BASE_CONFIG) for s in config_dirs]
# pip on Mac installs to the following path, but appdirs expects to
# follow Mac's BPFileSystem spec which doesn't include this path so
# we'll insert it. Issue raised as http://git.io/vOreU
mac_pip_cfg_path = "/usr/local/etc/bandit/bandit.yaml"
if mac_pip_cfg_path not in config_locations:
config_locations.append(mac_pip_cfg_path)
for config_file in config_locations:
if os.path.isfile(config_file):
return config_file # Found a valid config
else:
# Failed to find any config, raise an error.
raise utils.NoConfigFileFound(config_locations)
def get_config_path(filename='config.yaml',
appname=None,
appauthor=None,
appversion=None,
dirpath=None,
app_root_config=None,
user_config=None,
system_config=None,
approot_config_dirname='config'):
from os.path import join, dirname
# There are 4 options for dirpath:
# 0- given in dirpath argument
# 1- application root dir
# 2- user config dir
# 3- system config dir
if dirpath is None:
if app_root_config is False and user_config is False and system_config is False:
raise ValueError(
"Required one of: app_root_config, user_config, and system_config be True or None"
)
if app_root_config is True or not (user_config or system_config):
import sys
dirpath = join(dirname(sys.modules['__main__'].__file__),
approot_config_dirname)
elif user_config is True or not system_config:
import appdirs
dirpath = appdirs.user_config_dir(appname, appauthor, appversion)
else:
import appdirs
dirpath = appdirs.site_config_dir(appname, appauthor, appversion)
return join(dirpath, filename)
def get_config():
APP = "urlshortener"
AUTHOR = "132ikl"
paths = [
Path("/etc/urlshortener"),
Path(site_config_dir(APP, AUTHOR)),
Path(user_config_dir(APP, AUTHOR)),
Path(),
]
for path in paths:
f = path / "config.yml"
if f.exists():
LOGGER.info(f"Selecting config file {f}")
return open(f, "r")
for path in paths:
try:
path.mkdir(exist_ok=True)
template = resource_filename(__name__, "config.template.yml")
copyfile(template, (path / "config.template.yml"))
copyfile(template, (path / "config.yml"))
return open(path / "config.yml", "r")
except (PermissionError, OSError) as e:
LOGGER.warn(f"Failed to create config in {path}")
LOGGER.debug("", exc_info=True)
raise FileNotFoundError("Cannot find config.yml, and failed to create it")
def site_config_dir(self):
"""Return ``site_config_dir``."""
directory = appdirs.site_config_dir(self.appname, self.appauthor,
version=self.version, multipath=self.multipath)
if self.create:
self._ensure_directory_exists(directory)
return directory
def config_files(environ=None):
if environ is None:
environ = {}
# Lowest priority: hardcoded values
paths = os.pathsep.join(
[os.path.expanduser('~/.config/crestic'), '/etc/crestic'])
# Low priority: optional appdirs import
try:
import appdirs
paths = os.pathsep.join([
appdirs.user_config_dir('crestic'),
appdirs.site_config_dir('crestic', multipath=True)
])
except ImportError as e:
pass
# Medium priority: CRESTIC_CONFIG_PATHS
try:
paths = environ['CRESTIC_CONFIG_PATHS']
except KeyError:
pass
# High priority: CRESTIC_CONFIG_FILE
try:
return [environ['CRESTIC_CONFIG_FILE']]
except KeyError:
pass
return [os.path.join(x, 'crestic.cfg') for x in paths.split(os.pathsep)]
def main():
parser = argparse.ArgumentParser(description="Blinktrade Trade application")
parser.add_argument('-i', "--instance", action="store", dest="instance", help='Instance name', type=str)
parser.add_argument('-c', "--config", action="store", dest="config", default=os.path.expanduser('~/.bitex/bitex.ini'), help='Configuration file', type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [ os.path.join(ROOT_PATH, 'config/bitex.ini'),
os.path.join(site_config_dir('bitex'), 'bitex.ini'),
arguments.config]
config = ConfigParser.SafeConfigParser()
config.read( candidates )
options = ProjectOptions(config, arguments.instance)
if not options.trade_in or \
not options.trade_pub or \
not options.trade_log or \
not options.global_email_language or \
not options.db_engine:
raise RuntimeError("Invalid configuration file")
application = TradeApplication.instance()
application.initialize(options, arguments.instance)
application.run()
def loadSystemConfiguration():
config_path = os.path.join( appdirs.site_config_dir( 'jaminique' ), "config.json" )
if os.path.isfile( config_path ):
with open( config_path, 'rt' ) as configfile:
return ArgumentTree( configfile )
else:
return ArgumentTree()
def search_app_config_files(appname=None, appauthor=None, version=None):
pl = PathList()
cdirs = (appdirs.user_config_dir(appname, appauthor, version),
appdirs.site_config_dir(appname, appauthor, version))
for cdir in cdirs:
if pathlib.Path(cdir).exists():
pl.add(cdir)
return pl.list_files(['*.cfg', '*.json', '*.yaml'])
def get_dir(cls, level):
from appdirs import user_config_dir, site_config_dir
assert level in ("global", "system")
if level == "global":
return user_config_dir(cls.APPNAME, cls.APPAUTHOR)
if level == "system":
return site_config_dir(cls.APPNAME, cls.APPAUTHOR)
def loadSystemConfiguration():
config_path = os.path.join(appdirs.site_config_dir('jaminique'),
"config.json")
if os.path.isfile(config_path):
with open(config_path, 'rt') as configfile:
return ArgumentTree(configfile)
else:
return ArgumentTree()
def get_init_dir(parent_dir, prog_name):
"""get the init paths"""
pathnames = []
pathnames.append(appdirs.user_config_dir(
prog_name, PROG_AUTHOR)) # XDG Specification: ~/.config/prog_name/
pathnames.append(appdirs.site_config_dir(
prog_name, PROG_AUTHOR)) # XDG Specification: /etc/xdg/prog_name/
pathnames.append(os.path.join(parent_dir, CFG_DIRECTORY))
#print(pathnames)
return pathnames
def get_system_config_dir():
"""Returns system config location. E.g. /etc/dvc.conf.
Returns:
str: path to the system config directory.
"""
from appdirs import site_config_dir
return site_config_dir(appname=Config.APPNAME,
appauthor=Config.APPAUTHOR)
def read_options_file(options, fname):
for confdir in [ad.site_config_dir(appname, appauthor),
ad.user_config_dir(appname, appauthor)]:
path = op.join(confdir, fname)
# Note: logging level here is BEFORE the config was read. Typically INFO
logging.debug('checking for config at {0}'.format(path))
if op.isfile(path):
logging.debug('reading config from {0}'.format(path))
options._config_path = path
options.__dict__.update(read_config(
path, options._keys, options_glob))
def search_config():
name_candidates = ['slump.config', '.slumprc', 'slump_config']
path_candidates = [
Path('.'),
Path(user_config_dir('slump', 'slump')),
Path.home(),
Path(site_config_dir('slump', 'slump')),
]
for path_candidate in path_candidates:
for name_candidate in name_candidates:
if (path_candidate / name_candidate).is_file():
return path_candidate / name_candidate
return None
def main():
parser = argparse.ArgumentParser(
description="Blinktrade Api Receive application")
parser.add_argument(
'-c',
"--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/api_receive.ini'),
help='Configuration file',
type=str)
arguments = parser.parse_args()
if not arguments.config:
parser.print_help()
return
candidates = [
os.path.join(site_config_dir('blinktrade'), 'api_receive.ini'),
arguments.config
]
config = ConfigParser.SafeConfigParser()
config.read(candidates)
# Validate the whole file
for section_name in config.sections():
options = ProjectOptions(config, section_name)
if not options.log or \
not options.port or \
not options.rpc_url or \
not options.db_engine:
raise RuntimeError("Invalid configuration file")
# Start all applications
applications = []
for section_name in config.sections():
options = ProjectOptions(config, section_name)
application = ApiReceiveApplication(options, section_name)
application.listen(options.port)
applications.append(application)
if applications:
# start
try:
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
for application in applications:
application.clean_up()
def main():
parser = argparse.ArgumentParser(description="Blinktrade")
parser.add_argument('-c',
"--config",
action="store",
dest="config",
help='Configuration file',
type=str)
arguments = parser.parse_args()
candidates = [
os.path.join(site_config_dir('blinktrade'), 'bitex.ini'),
os.path.expanduser('~/.blinktrade/bitex.ini'), arguments.config
]
config = ConfigParser.SafeConfigParser()
config.read(candidates)
processes = []
for section_name in config.sections():
project_options = ProjectOptions(config, section_name)
if section_name[:5] == 'trade':
p = multiprocessing.Process(name=section_name,
target=partial(trade_instance,
section_name,
project_options))
elif section_name[:10] == 'ws_gateway':
p = multiprocessing.Process(name=section_name,
target=partial(ws_gateway_instance,
section_name,
project_options))
elif section_name[:6] == 'mailer':
p = multiprocessing.Process(name=section_name,
target=partial(mailer_instance,
section_name,
project_options))
else:
raise RuntimeError("Invalid section name")
processes.append(p)
# start all sub processes
for p in processes:
p.daemon = True
p.start()
# wait for them to finish
for p in processes:
logging.debug('waiting %s', p.name)
p.join()
def locate_config_file(configfile=OMEGA_CONFIG_FILE):
"""
locate the configuration file, if any
Will search the following locations for the config file:
1. current directory and all paths up to root
2. user configuration directory
3. site configuration directory
The exact location depends on the platform:
Linux:
user = ~/.config/omegaml
site = /etc/xdg/omegaml
Windows:
user = C:\Documents and Settings\<User>\Application Data\omegaml\omegaml
site = C:\Documents and Settings\All Users\Application Data\omegaml\omegaml
Mac:
user = ~/Library/Application Support/omegaml
site = /Library/Application Support/omegaml
See the appdirs package for details on the platform specific locations of the
user and site config dir, https://pypi.org/project/appdirs/
Args:
configfile: the default config file name or path
Returns:
location of the config file or None if not found
"""
try:
from appdirs import user_config_dir, site_config_dir
except:
# we don't have appdirs installed, this can happen during setup.py. fake it
user_config_dir = lambda *args: os.path.expanduser('~/.config/omegaml')
site_config_dir = lambda *args: '/etc/xdg/omegaml'
if os.path.exists(configfile):
return configfile
appdirs_args = ('omegaml', 'omegaml')
cur_dir_tree = lambda *args: Path(os.getcwd()).parents
all_dirs = (cur_dir_tree(), [user_config_dir(*appdirs_args)],
[site_config_dir(*appdirs_args)])
flatten = lambda l: (item for sl in l for item in sl)
for cfgdir in flatten(all_dirs):
cfgfile = os.path.join(cfgdir, os.path.basename(configfile))
if os.path.exists(cfgfile):
return cfgfile
return None
def getstorage(name, *args, **kwargs):
"""Get paths to storage directories.
This function maps generic names of storage directory to platform
specific paths which allows platform independent usage of storage
directories. This is a wrapper function to the module 'appdirs'.
For details and usage see:
http://github.com/ActiveState/appdirs
Args:
name (string): Storage path name: String describing storage
directory. Allowed values are:
'user_cache_dir' -- User specific cache directory
'user_config_dir' -- User specific configuration directory
'user_data_dir' -- User specific data directory
'user_log_dir' -- User specific logging directory
'site_config_dir' -- Site specific configuration directory
'site_data_dir' -- Site specific data directory
*args: Arguments passed to appdirs
**kwargs: Keyword Arguments passed to appdirs
Returns:
String containing path of storage directory or False if
storage path name is not supported.
"""
import appdirs
if name == 'user_cache_dir':
return appdirs.user_cache_dir(*args, **kwargs)
elif name == 'user_config_dir':
return appdirs.user_config_dir(*args, **kwargs)
elif name == 'user_data_dir':
return appdirs.user_data_dir(*args, **kwargs)
elif name == 'user_log_dir':
return appdirs.user_log_dir(*args, **kwargs)
elif name == 'user_cwd':
return getcwd()
elif name == 'site_config_dir':
return appdirs.site_config_dir(*args, **kwargs)
elif name == 'site_data_dir':
return appdirs.site_data_dir(*args, **kwargs)
return False
def find_config_dirs() -> Tuple[str, str]:
"""
The site and user configuration dirs for koji-smoky-dingo, as a
tuple. Attempts to use the ``appdirs`` package if it is available.
:since: 1.0
"""
if appdirs is None:
site_conf_dir = "/etc/xdg/ksd/"
user_conf_dir = expanduser("~/.config/ksd/")
else:
site_conf_dir = appdirs.site_config_dir("ksd")
user_conf_dir = appdirs.user_config_dir("ksd")
return (site_conf_dir, user_conf_dir)
def _get_config_paths():
user_dir = appdirs.user_config_dir("pip", appauthor=False, roaming=True)
site_dir = appdirs.site_config_dir("pip", appauthor=False, multipath=True)
config_files = [
os.path.join(user_dir, CONFIG_BASENAME),
os.path.join(site_dir, CONFIG_BASENAME),
]
if sys.platform.startswith("linux"):
config_files.append("/etc/pip.conf")
elif sys.platform == "win32" and site_dir is None or site_dir == r".\pip":
# Add a manual fallback to C:\ProgramData if it could not be programmatically
# determined
config_files.append(r"C:\ProgramData\pip\pip.ini")
return config_files
def find_config_file():
import appdirs
config_dirs = appdirs.site_config_dir(
'devpi-server', 'devpi', multipath=True)
config_dirs = config_dirs.split(os.pathsep)
config_dirs.append(
appdirs.user_config_dir('devpi-server', 'devpi'))
config_files = []
for config_dir in config_dirs:
config_file = os.path.join(config_dir, 'devpi-server.yml')
if os.path.exists(config_file):
config_files.append(config_file)
if len(config_files) > 1:
log.warn("Multiple configuration files found:\n%s", "\n".join(config_files))
if len(config_files):
return config_files[-1]
def create_config_path_if_necessary():
"""
Create path for saving MyData.cfg if it doesn't already exist.
"""
if sys.platform.startswith("win"):
# We use a setup wizard on Windows which runs with admin
# privileges, so we can ensure that the appdir_path below,
# i.e. C:\ProgramData\Monash University\MyData\ is
# writeable by all users.
appdir_path = appdirs.site_config_dir(APPNAME, APPAUTHOR)
else:
# On Mac, we currently use a DMG drag-and-drop installation, so
# we can't create a system-wide MyData.cfg writeable by all users.
appdir_path = appdirs.user_data_dir(APPNAME, APPAUTHOR)
if not os.path.exists(appdir_path):
os.makedirs(appdir_path)
return appdir_path
def _config_locations(filename):
""" Defines the list of places we can get configuration files from.
:param filename: The local name of the config file, e.g., 'spynnaker.cfg'
:type filename: str
:return: list of fully-qualified filenames
:rtype: list(str)
"""
dotname = "." + filename
# locations to read as well as default later overrides earlier
system_config_cfg_file = os.path.join(appdirs.site_config_dir(), dotname)
user_config_cfg_file = os.path.join(appdirs.user_config_dir(), dotname)
user_home_cfg_file = os.path.join(os.path.expanduser("~"), dotname)
# locations to read as well as default later overrides earlier
return [system_config_cfg_file, user_config_cfg_file, user_home_cfg_file]
def default_config_directories(
user_config_dir=None,
system_config_dir=None,
exedir=None,
repoonly=False,
verbose=0):
# Use configuration in the order (lowest to highest priority)
# If repoonly is true, start the procedure at step 4
# 1) same path as exe,
# 2) system config (XDG compliant. /etc/xdg/ct)
# 2b) python virtual environment system configs (${python-site-packages}/etc/xdg/ct)
# 3) user config (XDG compliant. ~/.config/ct)
# 4) repoconfig (usually <gitroot>/ct.conf.d TODO:make this configurable)
# 5) gitroot
# 6) current working directory
# 7) environment variables
# 8) given on the command line
# These variables are settable to assist writing tests
if user_config_dir is None:
user_config_dir = appdirs.user_config_dir(appname='ct')
system_dirs = []
if system_config_dir is not None:
system_dirs.append(system_config_dir)
else:
for python_config_dir in sys.path[::-1]:
trialpath = os.path.join(python_config_dir, 'etc/xdg/ct')
if ct.wrappedos.isdir(trialpath) and trialpath not in system_dirs:
system_dirs.append(trialpath)
system_dirs.append(appdirs.site_config_dir(appname='ct'))
if exedir is None:
exedir = ct.wrappedos.dirname(ct.wrappedos.realpath(sys.argv[0]))
executable_config_dir = os.path.join(exedir, "ct.conf.d")
gitroot = ct.git_utils.find_git_root()
results = ct.utils.OrderedSet([os.getcwd(), gitroot, os.path.join(gitroot,'ct.conf.d')])
if not repoonly:
results.append([user_config_dir] + system_dirs + [executable_config_dir])
if verbose >= 9:
print(" ".join(["Default config directories"] + list(results)))
return results
def default_config_directories(
user_config_dir=None, system_config_dir=None, exedir=None, repoonly=False, verbose=0
):
# Use configuration in the order (lowest to highest priority)
# If repoonly is true, start the procedure at step 4
# 1) same path as exe,
# 2) system config (XDG compliant. /etc/xdg/ct)
# 2b) python virtual environment system configs (${python-site-packages}/etc/xdg/ct)
# 3) user config (XDG compliant. ~/.config/ct)
# 4) repoconfig (usually <gitroot>/ct.conf.d TODO:make this configurable)
# 5) gitroot
# 6) current working directory
# 7) environment variables
# 8) given on the command line
# These variables are settable to assist writing tests
if user_config_dir is None:
user_config_dir = appdirs.user_config_dir(appname="ct")
system_dirs = []
if system_config_dir is not None:
system_dirs.append(system_config_dir)
else:
for python_config_dir in sys.path[::-1]:
trialpath = os.path.join(python_config_dir, "etc/xdg/ct")
if ct.wrappedos.isdir(trialpath) and trialpath not in system_dirs:
system_dirs.append(trialpath)
system_dirs.append(appdirs.site_config_dir(appname="ct"))
if exedir is None:
exedir = ct.wrappedos.dirname(ct.wrappedos.realpath(sys.argv[0]))
executable_config_dir = os.path.join(exedir, "ct.conf.d")
gitroot = ct.git_utils.find_git_root()
results = ct.utils.OrderedSet(
[os.getcwd(), gitroot, os.path.join(gitroot, "ct.conf.d")]
)
if not repoonly:
results.append([user_config_dir] + system_dirs + [executable_config_dir])
if verbose >= 9:
print(" ".join(["Default config directories"] + list(results)))
return results
def main():
parser = argparse.ArgumentParser(description="Blinktrade Api Receive application")
parser.add_argument('-c', "--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/api_receive.ini'),
help='Configuration file', type=str)
arguments = parser.parse_args()
if not arguments.config:
parser.print_help()
return
candidates = [ os.path.join(site_config_dir('blinktrade'), 'api_receive.ini'),
arguments.config ]
config = ConfigParser.SafeConfigParser()
config.read( candidates )
# Validate the whole file
for section_name in config.sections():
options = ProjectOptions(config, section_name)
if not options.log or \
not options.port or \
not options.rpc_url or \
not options.db_engine:
raise RuntimeError("Invalid configuration file")
# Start all applications
applications = []
for section_name in config.sections():
options = ProjectOptions(config, section_name)
application = ApiReceiveApplication(options, section_name)
application.listen(options.port)
applications.append(application)
if applications:
# start
try:
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
for application in applications:
application.clean_up()
def main():
parser = argparse.ArgumentParser(
description="Blinktrade Trade application")
parser.add_argument('-i',
"--instance",
action="store",
dest="instance",
help='Instance name',
type=str)
parser.add_argument('-c',
"--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/bitex.ini'),
help='Configuration file',
type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [
os.path.join(site_config_dir('blinktrade'), 'bitex.ini'),
os.path.expanduser('~/.blinktrade/bitex.ini'), arguments.config
]
config = ConfigParser.SafeConfigParser()
config.read(candidates)
options = ProjectOptions(config, arguments.instance)
if not options.trade_in or \
not options.trade_pub or \
not options.trade_log or \
not options.global_email_language or \
not options.sqlalchemy_connection_string or \
not options.sqlalchemy_engine:
raise RuntimeError("Invalid configuration file")
application = TradeApplication.instance()
application.initialize(options, arguments.instance)
application.run()
def main():
parser = argparse.ArgumentParser(description="Blinktrade")
parser.add_argument("-c", "--config", action="store", dest="config", help="Configuration file", type=str)
arguments = parser.parse_args()
candidates = [
os.path.join(site_config_dir("blinktrade"), "bitex.ini"),
os.path.expanduser("~/.blinktrade/bitex.ini"),
arguments.config,
]
config = ConfigParser.SafeConfigParser()
config.read(candidates)
processes = []
for section_name in config.sections():
project_options = ProjectOptions(config, section_name)
if section_name[:5] == "trade":
p = multiprocessing.Process(
name=section_name, target=partial(trade_instance, section_name, project_options)
)
elif section_name[:10] == "ws_gateway":
p = multiprocessing.Process(
name=section_name, target=partial(ws_gateway_instance, section_name, project_options)
)
elif section_name[:6] == "mailer":
p = multiprocessing.Process(
name=section_name, target=partial(mailer_instance, section_name, project_options)
)
else:
raise RuntimeError("Invalid section name")
processes.append(p)
# start all sub processes
for p in processes:
p.daemon = True
p.start()
# wait for them to finish
for p in processes:
logging.debug("waiting %s", p.name)
p.join()
def locate_config_file(configfile=OMEGA_CONFIG_FILE):
"""
locate the configuration file, if any
Will search the following locations for the config file:
1. current directory
2. user configuration directory
3. site configuration directory
The exact location depends on the platform:
Linux:
user = ~/.config/omegaml
site = /etc/xdg/omegaml
Windows:
user = C:\Documents and Settings\<User>\Application Data\omegaml\omegaml
site = C:\Documents and Settings\All Users\Application Data\omegaml\omegaml
Mac:
user = ~/Library/Application Support/omegaml
site = /Library/Application Support/omegaml
Args:
configfile: the default config file name or path
Returns:
location of the config file or None if not found
"""
try:
from appdirs import user_config_dir, site_config_dir
except:
# we don't have appdirs installed, this can happen during setup.py. fake it
user_config_dir = lambda *args: os.path.expanduser('~/.config/omegaml')
site_config_dir = lambda *args: '/etc/xdg/omegaml'
if os.path.exists(configfile):
return configfile
appdirs_args = ('omegaml', 'omegaml')
for cfgdir in (os.getcwd(), user_config_dir(*appdirs_args),
site_config_dir(*appdirs_args)):
cfgfile = os.path.join(cfgdir, os.path.basename(configfile))
if os.path.exists(cfgfile):
return cfgfile
return None
def main():
parser = argparse.ArgumentParser(
description="Blinktrade Mailer application")
parser.add_argument('-i',
"--instance",
action="store",
dest="instance",
help='Instance name',
type=str)
parser.add_argument('-c',
"--config",
action="store",
dest="config",
default=os.path.expanduser('~/.blinktrade/bitex.ini'),
help='Configuration file',
type=str)
arguments = parser.parse_args()
if not arguments.instance:
parser.print_help()
return
candidates = [
os.path.join(site_config_dir('blinktrade'), 'bitex.ini'),
os.path.expanduser('~/.blinktrade/bitex.ini'), arguments.config
]
config = ConfigParser.SafeConfigParser()
config.read(candidates)
options = ProjectOptions(config, arguments.instance)
if not options.mailchimp_apikey or\
not options.mandrill_apikey or\
not options.mailchimp_newsletter_list_id or\
not options.trade_in or\
not options.mailer_username or\
not options.mailer_password or\
not options.trade_pub or \
not options.mailer_log :
raise RuntimeError("Invalid configuration file")
run_application(options, arguments.instance)
def config_files(environ=None, config=None):
if environ is None:
environ = {}
# Lowest priority: hardcoded values
paths = os.pathsep.join([pathexpand("~/.config/crestic"), "/etc/crestic"])
# Low priority: optional appdirs import
try:
import appdirs
paths = os.pathsep.join([
appdirs.user_config_dir("crestic"),
appdirs.site_config_dir("crestic", multipath=True),
])
except ImportError:
pass
# Medium priority: CRESTIC_CONFIG_PATHS
try:
paths = environ["CRESTIC_CONFIG_PATHS"]
except KeyError:
pass
# High priority: CRESTIC_CONFIG_FILE
try:
return [environ["CRESTIC_CONFIG_FILE"]]
except KeyError:
pass
# High priority: crestic-config argument
if config is None:
pass
else:
try:
with open(config):
pass
return [config]
except FileNotFoundError:
pass
return [os.path.join(x, "crestic.cfg") for x in paths.split(os.pathsep)]
def init():
"""Load the config file."""
global config
config_file = os.path.join(appdirs.site_config_dir('reviewbot'),
'config.py')
print('Loading config file %s' % config_file)
try:
with open(config_file) as f:
config_module = imp.load_module('config', f, config_file,
('py', 'r', imp.PY_SOURCE))
for key in list(config.keys()):
if hasattr(config_module, key):
value = getattr(config_module, key)
config[key] = value
except:
print('Unable to load config, using defaults')
def init():
"""Load the config file."""
global config
config_file = os.path.join(appdirs.site_config_dir('reviewbot'),
'config.py')
print('Loading config file %s' % config_file)
try:
with open(config_file) as f:
config_module = imp.load_module('config', f, config_file,
('py', 'r', imp.PY_SOURCE))
for key in list(config.keys()):
if hasattr(config_module, key):
value = getattr(config_module, key)
config[key] = value
except:
print('Unable to load config, using defaults')
def _get_config_paths(app_name, app_author, default_config_filename='default', default_config_extension='.cfg'):
# FIXME this shouldn't create empty config files
default_config_filename = secure_filename(default_config_filename + default_config_extension)
user_config_filename = secure_filename(app_name + default_config_extension)
default_config_dir = appdirs.site_config_dir(app_name, app_author)
default_config_path = os.path.join(
default_config_dir,
default_config_filename
)
if not os.path.exists(default_config_dir):
os.makedirs(default_config_dir)
try:
if os.path.isfile(default_config_path):
log.debug("Opening config at: {0}".format(default_config_path,))
open(default_config_path, 'a').close()
else:
default_config_path = None
except FileNotFoundError:
log.warning("FileNotFoundError while opening config file at: {0}".format(default_config_path,))
#sys.exit(exit_codes.EX_OSFILE)
user_config_dir = appdirs.user_config_dir(app_name, app_author)
user_config_path = os.path.join(
user_config_dir,
user_config_filename
)
if not os.path.exists(user_config_dir):
os.makedirs(user_config_dir)
try:
if os.path.isfile(user_config_path):
log.debug("Opening config at: {0}".format(user_config_path,))
open(user_config_path, 'a').close()
else:
user_config_path = None
except FileNotFoundError:
log.warning("FileNotFoundError while opening config file at: {0}".format(user_config_path,))
#sys.exit(exit_codes.EX_OSFILE)
return [default_config_path, user_config_path,]
def loadConfig(app):
# Load in an default config
config = {
"production": ProdConfig,
"development": DevConfig,
"testing": TestConfig,
}[os.environ.get("SOMETHING_ENV", "production")]()
app.config.from_object(config)
app.config["config_file"] = None
# Try to load in user config file to override defaults
config_dir = Path(
appdirs.site_config_dir(something.__name__, something.__author__))
config_path_py = config_dir.joinpath("config.py")
config_path_json = config_dir.joinpath("config.json")
if config_path_py.exists():
app.config.from_pyfile(config_path_py, silent=True)
app.config["config_file"] = config_path_py
elif config_path_json.exists():
app.config.from_json(config_path_json)
app.config["config_file"] = config_path_json
def reload(self):
system_path = os.path.join(appdirs.site_config_dir('findex'), self._filename)
user_path = os.path.join(appdirs.user_config_dir('findex'), self._filename)
if not os.path.isfile(system_path) and not os.path.isfile(user_path):
raise ConfigNotFoundError('Could not load config file \'%s\' or \'%s\'.' % (user_path, system_path))
cfg = ConfigParser.ConfigParser()
cfg.read([system_path, user_path])
data = {}
for section in cfg.sections():
data[section] = {}
for k, v in cfg.items(section):
if k.startswith('#') or v.startswith('#'):
continue
if v:
try:
data[section][k] = int(v) if'.' not in v else float(v)
continue
except:
pass
if v.lower() == 'false':
data[section][k] = False
continue
elif v.lower() == 'true':
data[section][k] = True
continue
data[section][k] = v
self._validate_cfg(data)
self._items = data
#!/usr/bin/env python2 #-*- coding: utf-8 -*- __author__ = "Shrinidhi Rao" __license__ = "GPL" __email__ = "*****@*****.**" import sys import os import argparse import subprocess import appdirs import yaml os.environ['XDG_CONFIG_DIRS'] = '/etc' configdir = os.path.join(appdirs.site_config_dir(),"dev-ops") masterdir = os.path.join(configdir,"master") slavedir = os.path.join(configdir,"slave") supervisorpath = "/etc/supervisor/conf.d/" installdir = "/opt/dev-ops" states_path = "/srv/dev-ops/states/" events_root = "/srv/dev-ops/events/" masterconst_root = "/srv/dev-ops/masterconst/" progpath = installdir source_master_path = os.path.join(progpath,"install","master") source_slave_path = os.path.join(progpath,"install","slave") installed_slave_conf = os.path.join(slavedir,"slave.conf") slave_supervisorconf = os.path.join(progpath,"install","supervisor","slave")
def main():
parser = argparse.ArgumentParser(description="Process blinktrade withdrawals requests")
parser.add_argument('-c',
"--config",
action="store",
dest="config",
help='Configuration file', type=str)
arguments = parser.parse_args()
candidates = [ os.path.join(site_config_dir('blinktrade'), 'blinktrade_withdrawer.ini'),
os.path.expanduser('~/.blinktrade/blinktrade_withdrawer.ini')]
if arguments.config:
candidates.append(arguments.config)
config = ConfigParser.SafeConfigParser()
config.read( candidates )
password = getpass.getpass('password: '******'ws':
should_connect_on_ssl = False
blinktrade_port = 80
db_engine = config.get("database", "sqlalchemy_engine") + ':///' +\
os.path.expanduser(config.get("database", "sqlalchemy_connection_string"))
engine = create_engine(db_engine, echo=config.getboolean('database', 'sqlalchmey_verbose'))
Base.metadata.create_all(engine)
factory = BlinkTradeClientFactory(blinktrade_url.geturl())
factory.db_session = scoped_session(sessionmaker(bind=engine))
factory.verbose = config.getboolean("blinktrade", "verbose")
factory.blinktrade_broker_id = config.get("blinktrade", "broker_id")
factory.blinktrade_user = config.get("blinktrade", "api_key")
factory.blinktrade_password = decrypt(password, unhexlify(config.get("blinktrade", "api_password")))
factory.currencies = json.loads(config.get("blinktrade", "currencies"))
factory.methods = json.loads(config.get("blinktrade", "methods"))
factory.blocked_accounts = json.loads(config.get("blinktrade", "blocked_accounts"))
factory.mandrill_api = mandrill_api
if config.has_section('blockchain_info'):
from blockchain_info import BlockchainInfoWithdrawalProtocol
factory.blockchain_guid = decrypt(password, unhexlify(config.get("blockchain_info", "guid")))
factory.blockchain_main_password = decrypt(password, unhexlify(config.get("blockchain_info", "main_password")))
factory.blockchain_second_password = decrypt(password, unhexlify(config.get("blockchain_info", "second_password")))
factory.blockchain_api_key = config.get("blockchain_info", "api_key")
factory.from_address = config.get("blockchain_info", "from_address")
factory.note = config.get("blockchain_info", "note")
factory.protocol = BlockchainInfoWithdrawalProtocol
if config.has_section('blocktrail'):
import blocktrail
from mnemonic.mnemonic import Mnemonic
from pycoin.key.BIP32Node import BIP32Node
is_testnet = False
if config.get("blocktrail", "testnet") == '1':
is_testnet = True
client = blocktrail.APIClient(api_key=config.get("blocktrail", "api_key"),
api_secret=decrypt(password, unhexlify(config.get("blocktrail", "api_secret"))),
network='BTC',
testnet=is_testnet)
data = client.get_wallet(config.get("blocktrail", "wallet_identifier"))
primary_seed = Mnemonic.to_seed(data['primary_mnemonic'], decrypt(password, unhexlify(config.get("blocktrail", "wallet_passphrase"))))
primary_private_key = BIP32Node.from_master_secret(primary_seed, netcode='XTN' if client.testnet else 'BTC')
backup_public_key = BIP32Node.from_hwif(data['backup_public_key'][0])
checksum = client.create_checksum(primary_private_key)
if checksum != data['checksum']:
raise Exception("Checksum [%s] does not match expected checksum [%s], " \
"most likely due to incorrect password" % (checksum, data['checksum']))
blocktrail_public_keys = {}
for v,k in data['blocktrail_public_keys']:
if k in blocktrail_public_keys:
blocktrail_public_keys[k].append(v)
else:
blocktrail_public_keys[k] = [v]
key_index = data['key_index']
wallet = blocktrail.wallet.Wallet(client=client,
identifier= config.get("blocktrail", "wallet_identifier"),
primary_mnemonic=data['primary_mnemonic'],
primary_private_key=primary_private_key,
backup_public_key=backup_public_key,
blocktrail_public_keys=blocktrail_public_keys,
key_index=key_index,
testnet=client.testnet)
from blocktrail_protocol import BlocktrailWithdrawalProtocol
factory.blocktrail_wallet = wallet
factory.blocktrail_change_address = config.get("blocktrail", "change_address")
factory.protocol = BlocktrailWithdrawalProtocol
if config.has_section('mailer'):
from mailer_protocol import MailerWithdrawalProtocol
factory.mandrill_apikey = config.get("mailer", "mandrill_apikey")
factory.mandrill_template_name = config.get("mailer", "template_name")
factory.mandrill_from_email = config.get("mailer", "from_email")
factory.mandrill_from_name = config.get("mailer", "from_name")
factory.mandrill_to_email = config.get("mailer", "to_email")
factory.mandrill_to_name = config.get("mailer", "to_name")
factory.mandrill_website = config.get("mailer", "website")
factory.protocol = MailerWithdrawalProtocol
if should_connect_on_ssl:
reactor.connectSSL( blinktrade_url.netloc , blinktrade_port , factory, ssl.ClientContextFactory() )
else:
reactor.connectTCP(blinktrade_url.netloc , blinktrade_port , factory )
reactor.run()
import appdirs
import errno
import logging
import os
import yaml
from virt_backup import APP_NAME
logger = logging.getLogger("virt_backup")
os.environ["XDG_CONFIG_DIRS"] = "/etc"
CONFIG_DIRS = (
appdirs.user_config_dir(APP_NAME),
appdirs.site_config_dir(APP_NAME),
)
CONFIG_FILENAME = "config.yml"
def get_config(custom_path=None):
"""
Get config file and load it with yaml
:returns: loaded config in yaml, as a dict object
"""
if custom_path:
config_path = custom_path
else:
for d in CONFIG_DIRS:
config_path = os.path.join(d, CONFIG_FILENAME)
if os.path.isfile(config_path):
import json
import os
import sys
from binascii import hexlify
from appdirs import site_config_dir
config_file_dir = site_config_dir("Prophasis", "Prophasis")
config_file_path = os.path.join(config_file_dir, "core.conf.json")
def get_config():
try:
with open(config_file_path, "r") as f:
config = json.load(f)
except FileNotFoundError:
raise SystemExit("Config file, config.json not found at {0}, perhaps "
"you need to run the core setup script?".format(config_file_path))
return config
def get_config_value(config, key):
try:
return config[key]
except KeyError:
raise SystemExit("Key \"{0}\" does not exist in config.json, did you "
"run core setup?".format(key))
import os
import appdirs
# Application metadata
__author__ = "FujiMakoto"
__copyright__ = "Copyright 2016, FujiMakoto"
__license__ = "MIT"
__version__ = "0.2.0"
__maintainer__ = "FujiMakoto"
__email__ = "*****@*****.**"
__status__ = "Prototype"
# Global paths
APP_DIR = os.path.dirname(__file__)
PLUGIN_DIR = os.path.join(APP_DIR, 'commands')
DATA_DIR = os.path.join(APP_DIR, 'data')
USER_CONFIG_DIR = appdirs.user_config_dir('tumdlr')
SITE_CONFIG_DIR = appdirs.site_config_dir('tumdlr')
USER_DATA_DIR = appdirs.user_data_dir('tumdlr')
SITE_DATA_DIR = appdirs.site_config_dir('tumdlr')
USER_LOG_DIR = appdirs.user_log_dir('tumdlr')
import errno
import logging
from os.path import expanduser
from os.path import join as join_path
from sys import exit
from ruamel import yaml
import requests
from appdirs import site_config_dir, user_config_dir
from . import __version__
DEFAULT_CONFIG = join_path(user_config_dir('ntfy', 'dschep'), 'ntfy.yml')
SITE_DEFAULT_CONFIG = join_path(site_config_dir('ntfy', 'dschep'), 'ntfy.yml')
OLD_DEFAULT_CONFIG = '~/.ntfy.yml'
USER_AGENT = 'ntfy/{version} {default_user_agent}'.format(
version=__version__,
default_user_agent=requests.utils.default_user_agent())
def load_config(config_path=DEFAULT_CONFIG):
logger = logging.getLogger(__name__)
try:
config = yaml.load(open(expanduser(config_path)))
except IOError as e:
if e.errno == errno.ENOENT and config_path == DEFAULT_CONFIG:
logger.info('{} not found'.format(config_path))
config = {}
else:
import errno
import logging
from os.path import expanduser
from os.path import join as join_path
from sys import exit
from ruamel import yaml
import requests
from appdirs import site_config_dir, user_config_dir
from . import __version__
DEFAULT_CONFIG = join_path(user_config_dir("ntfy", "dschep"), "ntfy.yml")
SITE_DEFAULT_CONFIG = join_path(site_config_dir("ntfy", "dschep"), "ntfy.yml")
OLD_DEFAULT_CONFIG = expanduser("~/.ntfy.yml")
USER_AGENT = "ntfy/{version} {default_user_agent}".format(
version=__version__, default_user_agent=requests.utils.default_user_agent()
)
def load_config(config_path=DEFAULT_CONFIG):
logger = logging.getLogger(__name__)
try:
config = yaml.load(open(expanduser(config_path)))
except IOError as e:
if e.errno == errno.ENOENT and config_path == DEFAULT_CONFIG:
logger.info("{} not found".format(config_path))
config = {}
else:
def main():
parser = argparse.ArgumentParser(description="Process blinktrade withdrawals requests")
parser.add_argument('-c',
"--config",
action="store",
dest="config",
help='Configuration file', type=str)
arguments = parser.parse_args()
candidates = [ os.path.join(site_config_dir('blinktrade'), 'blinktrade_withdrawer.ini'),
os.path.expanduser('~/.blinktrade/blinktrade_withdrawer.ini')]
if arguments.config:
candidates.append(arguments.config)
config = ConfigParser.SafeConfigParser()
config.read( candidates )
password = getpass.getpass('password: '******'ws':
should_connect_on_ssl = False
blinktrade_port = 80
db_engine = config.get("database", "sqlalchemy_engine") + ':///' +\
os.path.expanduser(config.get("database", "sqlalchemy_connection_string"))
engine = create_engine(db_engine, echo=config.getboolean('database', 'sqlalchmey_verbose'))
Base.metadata.create_all(engine)
factory = BlinkTradeClientFactory(blinktrade_url.geturl())
factory.db_session = scoped_session(sessionmaker(bind=engine))
factory.verbose = config.getboolean("blinktrade", "verbose")
factory.blinktrade_broker_id = config.get("blinktrade", "broker_id")
factory.blinktrade_user = decrypt(password, unhexlify(config.get("blinktrade", "user")))
factory.blinktrade_password = decrypt(password, unhexlify(config.get("blinktrade", "password")))
factory.currencies = json.loads(config.get("blinktrade", "currencies"))
factory.methods = json.loads(config.get("blinktrade", "methods"))
factory.blocked_accounts = json.loads(config.get("blinktrade", "blocked_accounts"))
if config.has_section('blockchain_info'):
from blockchain_info import BlockchainInfoWithdrawalProtocol
factory.blockchain_guid = decrypt(password, unhexlify(config.get("blockchain_info", "guid")))
factory.blockchain_main_password = decrypt(password, unhexlify(config.get("blockchain_info", "main_password")))
factory.blockchain_second_password = decrypt(password, unhexlify(config.get("blockchain_info", "second_password")))
factory.from_address = config.get("blockchain_info", "from_address")
factory.note = config.get("blockchain_info", "note")
factory.protocol = BlockchainInfoWithdrawalProtocol
if config.has_section('mailer'):
from mailer_protocol import MailerWithdrawalProtocol
factory.mandrill_apikey = config.get("mailer", "mandrill_apikey")
factory.mandrill_template_name = config.get("mailer", "template_name")
factory.mandrill_from_email = config.get("mailer", "from_email")
factory.mandrill_from_name = config.get("mailer", "from_name")
factory.mandrill_to_email = config.get("mailer", "to_email")
factory.mandrill_to_name = config.get("mailer", "to_name")
factory.mandrill_website = config.get("mailer", "website")
factory.protocol = MailerWithdrawalProtocol
if should_connect_on_ssl:
reactor.connectSSL( blinktrade_url.netloc , blinktrade_port , factory, ssl.ClientContextFactory() )
else:
reactor.connectTCP(blinktrade_url.netloc , blinktrade_port , factory )
reactor.run()
logging.getLogger().setLevel(logging.INFO)
# Build up a list of potential config files to parse.
config_paths = []
try:
import appdirs
except ImportError:
logging.warn("appdirs not installed, not reading site/user config")
else:
config_paths.append(
os.path.join(
appdirs.user_config_dir(APP_NAME, APP_AUTHOR),
CONFIG_FILE_NAME))
config_paths.append(
os.path.join(
appdirs.site_config_dir(APP_NAME, APP_AUTHOR),
CONFIG_FILE_NAME))
if cli_args.config:
config_paths.append(cli_args.config)
if cli_args.cmd == "print_config_paths":
for config_path in config_paths:
print config_path
sys.exit(0)
# Attempt to open each config file, and update the `cfg` dict with each
# one.
cfg = {}
for config_path in config_paths:
try:
with open(config_path) as f:
