def init_config():
config_obj = config.Config()
[
setattr(config_obj, variable, getattr(config, variable, ''))
for variable in dir(config) if not variable.startswith("__")
]
return config_obj
def __init__(self):
self.tmdb = movieinfo.TMDB()
self.config = config.Config()
self.metadata = library.Metadata()
self.predb = predb.PreDB()
self.searcher = searcher.Searcher()
self.score = searchresults.Score()
self.snatcher = snatcher.Snatcher()
self.version = version.Version()
def __init__(self):
self.omdb = Omdb()
self.config = config.Config()
self.predb = predb.PreDB()
self.searcher = searcher.Searcher()
self.sql = sqldb.SQL()
self.poster = poster.Poster()
self.snatcher = snatcher.Snatcher()
self.update = updatestatus.Status()
def __init__(self):
self.itunes = ITunes()
self.config = config.Config()
self.library = library.ImportDirectory()
self.predb = predb.PreDB()
self.plugins = plugins.Plugins()
self.searcher = searcher.Searcher()
self.score = scoreresults.ScoreResults()
self.sql = sqldb.SQL()
self.musicinfo = musicinfo.ITunes()
self.snatcher = snatcher.Snatcher()
self.update = updatestatus.Status()
def __init__(self):
self.tmdb = TMDB()
self.config = config.Config()
self.library = library.ImportDirectory()
self.predb = predb.PreDB()
self.plugins = plugins.Plugins()
self.searcher = searcher.Searcher()
self.score = scoreresults.ScoreResults()
self.sql = sqldb.SQL()
self.poster = poster.Poster()
self.snatcher = snatcher.Snatcher()
self.update = updatestatus.Status()
def __init__(self):
# basic variables
self.start_time = time.time()
self.running = True
self.do_restart = False
# stores all queued messages from all connections
self.queued_messages = queue.Queue()
# format: [{
# "conn": BotConnection, "raw": str, "prefix": str, "command": str, "params": str, "nick": str,
# "user": str, "host": str, "mask": str, "paramlist": list[str], "lastparam": str
# }]
# stores each bot server connection
self.connections = []
# set up logging
self.logger = get_logger()
self.logger.debug("Logging system initialised.")
# declare and create data folder
self.data_dir = os.path.abspath('data')
if not os.path.exists(self.data_dir):
self.logger.debug("Data folder not found, creating.")
os.mkdir(self.data_dir)
# set up config
self.config = config.Config(self)
self.logger.debug("Config system initialised.")
# setup db
db_path = self.config.get('database', 'sqlite:///cloudbot.db')
self.db_engine = create_engine(db_path)
self.db_factory = sessionmaker(bind=self.db_engine)
self.db_session = scoped_session(self.db_factory)
self.db_metadata = MetaData()
# set botvars.metadata so plugins can access when loading
botvars.metadata = self.db_metadata
self.logger.debug("Database system initialised.")
# Bot initialisation complete
self.logger.debug("Bot setup completed.")
self.threads = {}
# create bot connections
self.create_connections()
# run plugin loader
self.plugin_manager = PluginManager(self)
self.loader = PluginLoader(self)
def __init__(self):
self.tmdb = TMDB()
self.config = config.Config()
self.metadata = library.Metadata()
self.predb = predb.PreDB()
self.plugins = plugins.Plugins()
self.searcher = searcher.Searcher()
self.score = searchresults.Score()
self.sql = sqldb.SQL()
self.library = library
self.poster = poster.Poster()
self.snatcher = snatcher.Snatcher()
self.update = library.Status()
def main():
args = docopt.docopt(__doc__, version='Jenkins Helper 1.0')
# print(args)
cfg = config.Config()
cfg.root_dir = ROOT_DIR
if not cfg.load("./config.json"):
exit(1)
cmd = command_factory.create(args)
if cmd:
cmd.process_args(cfg, args)
cmd.do_command()
else:
print('command not found.')
def setup(self):
"""create the logger and config objects"""
# logging
self.logger = get_logger()
self.logger.debug("Logging engine started.")
# data folder
self.data_dir = os.path.abspath('persist')
if not os.path.exists(self.data_dir):
self.logger.debug("Data folder not found, creating.")
os.mkdir(self.data_dir)
self.logger.debug("Created data folder.")
# config
self.config = config.Config(self.logger)
self.logger.debug("Config object created.")
def __init__(self):
self.api = None
self.module = None
self.module_name = None
self.final_url = None
self.port = None
self.enable_2fa = None
self.seen = set()
self.verbose = False
self.hostname = None
#app = Flask(
#__name__,
#static_url_path='/modules/{}/templates/'.format(self.module_name)
#)
self.validate_args()
self.prepare_storage()
self.prepare_module()
self.prepare_api()
# TODO: Move parameters to a config for sharing
self.config = config.Config()
import string
import datetime
import json
import urllib.request
import urllib.error
import traceback
from core import config, common, database, tags, lastfm, spotify, CONFIG_PATH
# ############################################################################
# 1. Inizializzazione
# ############################################################################
print("* initialization...")
# configuration intialization
cfg = config.Config(CONFIG_PATH)
# drop old db
common.delete(cfg.getDb())
# istanza db
db = database.Database(cfg.getDb())
db.open()
# inizializzazione e caricamento schema logico
with open(cfg.getSchema()) as sh:
ddl = sh.read()
db.executeScript(ddl)
# count operazioni
added, errors = 0, 0
def __init__(self, verbose=False):
try:
if args.directory:
os.chdir(args.directory)
except:
pass
self.config = cfg.Config(verbose=verbose, colored=True)
self.config.load()
self.config.fallback = {
"aliases": {},
"colored": True,
"prompt": "<base>┏━━(</base><user>${USER}</user> <base>at</base> <user>${DOMAIN}</user><base>)━[</base><path>${PATH}</path><base>]━[</base><style fg='${green-yellow}'>${REPO}</style><base>]━[</base><style fg='yellow'>${TIME}</style><base>]\n┗━</base><pointer>${ROOT}</pointer> ",
"style": {
# Default style
"": "",
# Specific style
"base": "#1a8cff",
"pointer": "#ff4500",
"path": "aqua",
"user": "******",
# Completer
"completion-menu.completion": "bg:#000000 #ffffff",
"completion-menu.completion.current": "bg:#00aaaa #000000",
"scrollbar.background": "bg:#88aaaa",
"scrollbar.button": "bg:#222222"
},
"dialog_style": {
"dialog": "bg:#88ff88",
"dialog frame-label": "bg:#ffffff #000000",
"dialog.body": "bg:#000000 #00ff00",
"dialog shadow": "bg:#00aa00",
}
}
self.config.colored = self.config["colored"]
self.style = Style.from_dict(self.config["style"])
self.dialog_style = Style.from_dict(self.config["dialog_style"])
self.manager = manager
self.file = None
self.mode = None
self.userInput = None
if platform.system() == "Windows":
self.histfile = os.environ["userprofile"] + \
r"\.voidhistory" # Rename this
else:
# Rename this ... alternative for linux or Unix based systems
self.histfile = os.path.expanduser("~")+r"/.voidhistory"
self.history = FileHistory(self.histfile)
if not args.command:
function_completer = NestedCompleter.from_nested_dict(
dict.fromkeys(functions))
pth_completer = path_completer.PathCompleter(expanduser=True)
environ_completer = env_completer.EnvCompleter(
file_filter=filter)
merged_completers = merge_completers(
[function_completer, pth_completer, environ_completer])
self.completer = ThreadedCompleter(merged_completers)
else:
self.completer = None
super().__init__(completer=self.completer,
complete_while_typing=False,
auto_suggest=AutoSuggestFromHistory(),
search_ignore_case=True,
refresh_interval=0,
color_depth=ColorDepth.TRUE_COLOR,
editing_mode=EditingMode.VI,
style=self.style,
history=self.history)
def __init__(self):
self.config = config.Config()
self.tmdb = TMDB()
self.sql = sqldb.SQL()
self.ajax = ajax.Ajax()
return
class Tucan:
""""""
def __init__(self):
""""""
#parse options
parser = optparse.OptionParser()
parser.add_option("-w",
"--wizard",
dest="wizard",
help="setup: accounts, services, updates",
metavar="TYPE")
parser.add_option("-d",
"--daemon",
action="store_true",
dest="daemon",
default=False,
help="no interaction interface (URL)")
parser.add_option("-c",
"--cli",
action="store_true",
dest="cli",
default=False,
help="command line interface (URL)")
parser.add_option("-C",
"--clean",
action="store_true",
dest="clean",
default=False,
help="remove ~/.tucan")
parser.add_option("-i",
"--input-links",
dest="links_file",
help="import links from FILE",
metavar="FILE")
parser.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="print log to stdout")
parser.add_option("-V",
"--version",
action="store_true",
dest="version",
default=False,
help="print version and exit")
self.options, self.args = parser.parse_args()
if self.options.version:
sys.exit("%s %s" % (cons.TUCAN_NAME, cons.TUCAN_VERSION))
if self.options.clean:
try:
misc.remove_conf_dir()
except Exception, e:
sys.exit(e)
if not os.path.exists(cons.CONFIG_PATH):
os.mkdir(cons.CONFIG_PATH)
#check for previous running instance
self.pid_file = pid_file.PidFile(cons.PID_FILE)
if self.pid_file.start():
#config
shared.configuration = config.Config()
self.config = shared.configuration
sys.path.append(cons.PLUGIN_PATH)
#logging
if os.path.exists(cons.LOG_FILE):
if os.path.exists("%s.old" % cons.LOG_FILE):
os.remove("%s.old" % cons.LOG_FILE)
os.rename(cons.LOG_FILE, "%s.old" % cons.LOG_FILE)
logging.basicConfig(level=logging.DEBUG,
format=cons.LOG_FORMAT,
filename=cons.LOG_FILE,
filemode='w')
self.logger = logging.getLogger(self.__class__.__name__)
else:
if self.options.wizard or self.options.daemon or self.options.cli:
sys.exit(
"Already running or could not open ~/.tucan/tucan.pid")
else:
self.start_gui(False)
sys.exit()
#!/bin/env python3
from flask import Flask
from core import config
from core import db
from apis import api
app = Flask(__name__)
app.config.from_object(config.Config())
db.init_app(app)
api.init_app(app)
if __name__ == '__main__':
app.run(host='0.0.0.0')
def compDPK(fn_conf, chem=None, sc_Kw_paras=None, sc_D_paras=None, disp=1, wk_path= '.\\simu\\'):
"""Compute DPK
Args:
fn_conf -- the .cfg file, which gives the configuration of the simulation
chem -- if given, it overrides the values given in fn_conf
wk_path -- path to save simulation results
"""
# --------------------------------------------------------------------------------------------------------------
import os
import numpy as np
from importlib import reload
from core import chemical
reload(chemical)
from core import config
reload(config)
from core import vehicle
reload(vehicle)
from core import viaepd
reload(viaepd)
from core import dermis
reload(dermis)
from core import skin_setup
reload(skin_setup)
from core.saveMass_hobin import saveMass #Can not reload the saveMass since saveMass is not module
wk_path = os.path.join(os.path.split(os.path.split(fn_conf)[0])[0],wk_path)
# --------------------------------------------------------------------------------------------------------------
# Read the .cfg, i.e. configuration, file to set up simulation
_conf = config.Config(fn_conf)
if sc_Kw_paras is not None:
_conf.Kw_sc_paras = sc_Kw_paras
if sc_D_paras is not None:
_conf.D_sc_paras = sc_D_paras
# Setup the chemical
if chem is not None:
_chem = chem
else:
_chem = chemical.Chemical(_conf)
# Setup skin and create compartments
_skin = skin_setup.Skin_Setup(_chem, _conf)
_skin.createComps(_chem, _conf)
# Simulation time (in seconds) and steps
t_start, t_end, Nsteps = [0, 3600 * 24, 145]
# t_start, t_end, Nsteps = [0, 1800, 181]
t_range = np.linspace(t_start, t_end, Nsteps)
# t_range = np.r_[np.linspace(0, 1000, 2), np.linspace(1200, 1800, 21),\
# np.linspace(1800, 3600, 21),np.linspace(7200, 3600*24, 23)]
# Nsteps = len(t_range)
nComps = _skin.nxComp * _skin.nyComp
total_mass = np.sum(_skin.compMass_comps())
# Create directory to save results
newpath = wk_path
if not os.path.exists(newpath):
os.makedirs(newpath)
fn = wk_path + 'MassFrac.csv'
saveMass(total_mass, fn, b_1st_time=True)
for i in range(Nsteps):
mass = _skin.compMass_comps()
m_v = _skin.comps[0].getMass_OutEvap()
m_all = np.insert(mass, 0, m_v) / total_mass
if disp >= 2:
np.set_printoptions(precision=2)
# print('Time = ', t_range[i], '% mass: ', m_all)
# Create directory to save results
newpath = wk_path + str(t_range[i])
if not os.path.exists(newpath):
os.makedirs(newpath)
# Save fraction of mass in all compartments
fn = wk_path + 'MassFrac.csv'
saveMass(np.insert(m_all, 0, t_range[i]), fn)
# Save current concentrations
for j in range(nComps):
fn = newpath + '/comp' + str(j) + '_' + _conf.comps_geom[j].name
_skin.comps[j].saveMeshConc(True, fn)
if i == Nsteps - 1:
break
# Simulate
_skin.solveMoL(t_range[i], t_range[i + 1])
# return mass
parser.add_argument('-b', '--browser', help='Open browser on launch.',
action='store_true')
parser.add_argument('-c', '--conf', help='Location of config file.',
type=str)
parser.add_argument('-l', '--log',
help='Directory in which to create log files.', type=str)
passed_args = parser.parse_args()
# Set up conf file
if passed_args.conf:
core.CONF_FILE = passed_args.conf
if passed_args.log:
core.LOG_DIR = passed_args.log
# set up config file on first launch
conf = config.Config()
if not os.path.isfile(core.CONF_FILE):
print 'Config file not found. Creating new basic config {}. ' \
'Please review settings.'.format(core.CONF_FILE)
conf.new_config()
else:
print 'Config file found, merging any new options.'
conf.merge_new_options()
conf.stash()
# Set up logging
if passed_args.log:
core.LOG_DIR = passed_args.log
log.start(core.LOG_DIR)
logging = logging.getLogger(__name__)
cherrypy.log.error_log.propagate = True
import re
import subprocess
import tensorflow as tf
import numpy as np
import os
import core.loader as ld
import core.trainer as tn
import core.network as nw
import core.config as cf
import core.evaluator as ev
from LaTeXTools.LATEXwriter import LATEXwriter as TeXwriter
import lime.lime_text
import lime.lime_tabular
from multiprocessing import Process
cf = cf.Config()
def launchTensorBoard(path):
import os
os.system(
"bash -c \"source /home/chambroc/miniconda3/bin/activate bob && tensorboard --logdir="
+ path + "\"")
return
os.mkdir(cf.tb_dir)
os.mkdir(cf.tb_dir + "/train")
os.mkdir(cf.tb_dir + "/test")
os.mkdir(cf.tb_dir + "/lime")
os.mkdir(cf.tb_dir + "/log")
