def main(kernel, part, unroll, pipe, clock_period):
if not "ALADDIN_HOME" in os.environ:
raise Exception("Set ALADDIN_HOME directory as an environment variable")
if not "TRACER_HOME" in os.environ:
raise Exception("Set TRACER_HOME directory as an environment variable")
ALADDIN_HOME = os.getenv("ALADDIN_HOME")
BENCH_HOME = ALADDIN_HOME + "/SHOC/" + kernel
os.chdir(BENCH_HOME)
d = "p%s_u%s_P%s_%sns" % (part, unroll, pipe, clock_period)
# Run LLVM-Tracer to generate the dynamic trace
# Only need to run once to generate the design space of each algorithm
# All the Aladdin runs use the same trace
llvm_compile.main(BENCH_HOME, kernel)
# Generate accelerator design config file
config.main(BENCH_HOME, kernel, part, unroll, pipe, clock_period)
print "Start Aladdin"
trace_file = BENCH_HOME + "/" + "dynamic_trace.gz"
config_file = "config_" + d
newdir = os.path.join(BENCH_HOME, "sim", d)
print "Changing directory to %s" % newdir
os.chdir(newdir)
os.system("%s/common/aladdin %s %s %s" % (os.getenv("ALADDIN_HOME"), kernel, trace_file, config_file))
def main(kernel, part, unroll, pipe, clock_period):
if not 'ALADDIN_HOME' in os.environ:
raise Exception(
'Set ALADDIN_HOME directory as an environment variable')
if not 'TRACER_HOME' in os.environ:
raise Exception('Set TRACER_HOME directory as an environment variable')
ALADDIN_HOME = os.getenv('ALADDIN_HOME')
BENCH_HOME = ALADDIN_HOME + '/SHOC/' + kernel
os.chdir(BENCH_HOME)
d = 'p%s_u%s_P%s_%sns' % (part, unroll, pipe, clock_period)
#Run LLVM-Tracer to generate the dynamic trace
#Only need to run once to generate the design space of each algorithm
#All the Aladdin runs use the same trace
llvm_compile.main(BENCH_HOME, kernel)
#Generate accelerator design config file
config.main(BENCH_HOME, kernel, part, unroll, pipe, clock_period)
print 'Start Aladdin'
trace_file = BENCH_HOME + '/' + 'dynamic_trace.gz'
config_file = 'config_' + d
newdir = os.path.join(BENCH_HOME, 'sim', d)
print 'Changing directory to %s' % newdir
os.chdir(newdir)
os.system('%s/common/aladdin %s %s %s' % \
(os.getenv('ALADDIN_HOME'), kernel, trace_file, config_file))
def main():
# initialize the configuration
config.main()
# create the mandatory wx application object
app = wx.App(redirect=False)
# test for availability of our listening port
interface = config.get('client', 'listen_interface')
port = config.getint('client', 'listen_port')
log.info('opening TorChat listener on %s:%s' % (interface, port))
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
log.info('%s:%s is already in use' % (interface, port))
wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE
% (interface, port),
tc_gui.lang.D_WARN_USED_PORT_TITLE)
return
else:
log.info('TorChat is listening on %s:%s' % (interface, port))
# now continue with normal program startup
log.info('start initializing main window')
app.mw = tc_gui.MainWindow(listen_socket)
app.SetTopWindow(app.mw)
log.info('main window initialized')
log.info('entering main loop')
app.MainLoop()
def naviLangContent(self):
configdict = config.main("config.txt")
langstring = configdict["lang"]
langlist = langstring.split(",")
seitendict = config.main("seiten.txt")
sprachendict = config.main("sprachen.txt")
for target_lang in langlist:
target_lang_path = sprachendict[target_lang + "-pfad"]
# navi_text = sprachendict[$target_lang][text]
target_dir = seitendict["Sites"+ self.act_id + "-" + target_lang + "ordner"]
target_file = seitendict["Sites" + self.act_id + "-" + target_lang + "datei"]
if target_file != "" and self.act_lang_path != target_lang_path:
if self.switch == "":
self.switch = 1
Content += ' <ul class="navi-lang">\n'
end = " </ul>\n"
self.navi_target = "/" + target_lang_path + target_dir
if target_file[0:6] != "index.":
self.navi_target += target_file
Content += ' <li><a href="' + self.navi_target + '">' + self.navi_text + "</a></li>\n"
Content += end + "\n"
return Content
def main():
# initialize the configuration
config.main()
# create the mandatory wx application object
app = wx.App(redirect=False)
# test for availability of our listening port
interface = config.get('client', 'listen_interface')
port = config.getint('client', 'listen_port')
log.info('opening TorChat listener on %s:%s' % (interface, port))
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
log.info('%s:%s is already in use' % (interface, port))
wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE % (interface, port),
tc_gui.lang.D_WARN_USED_PORT_TITLE)
return
else:
log.info('TorChat is listening on %s:%s' % (interface, port))
# now continue with normal program startup
log.info('start initializing main window')
app.mw = tc_gui.MainWindow(listen_socket)
app.SetTopWindow(app.mw)
log.info('main window initialized')
log.info('entering main loop')
app.MainLoop()
def main(benches, part, unroll, pipe, clock_period):
print 'Running on %s' % socket.gethostname()
part = int(part)
unroll = int(unroll)
if not 'ALADDIN_HOME' in os.environ:
raise Exception(
'Set ALADDIN_HOME directory as an environment variable')
if not 'TRACER_HOME' in os.environ:
raise Exception('Set TRACER_HOME directory as an environment variable')
if not 'MACH_HOME' in os.environ:
raise Exception('Set MACH_HOME directory as an environment variable')
ALADDIN_HOME = os.getenv('ALADDIN_HOME')
MACH_HOME = os.getenv('MACH_HOME')
if benches == 'all':
benches = main_kernel_c.iterkeys()
else:
benches = benches.split(",")
for bench in benches:
print ""
print '#' * 20
print " %s" % bench
print '#' * 20
kernel = bench.split('-')[0]
algorithm = bench.split('-')[1]
BENCH_HOME = MACH_HOME + '/' + kernel + '/' + algorithm
print BENCH_HOME
os.chdir(BENCH_HOME)
d = 'p%s_u%s_P%s_%sns' % (part, unroll, pipe, clock_period)
#Run LLVM-Tracer to generate the dynamic trace
print bench
source = main_kernel_c[bench]
llvm_compile.main(BENCH_HOME, bench, source)
#Generate accelerator design config file
config.main(BENCH_HOME, kernel, algorithm, part, unroll, pipe,
clock_period)
print 'Start Aladdin'
trace_file = BENCH_HOME + '/' + 'dynamic_trace.gz'
config_file = 'config_' + d
newdir = os.path.join(BENCH_HOME, 'sim', d)
print 'Changing directory to %s' % newdir
os.chdir(newdir)
os.system('%s/common/aladdin %s %s %s ' %
(os.getenv('ALADDIN_HOME'), bench, trace_file, config_file))
def main(benches, part, unroll, pipe, clock_period):
print 'Running on %s' % socket.gethostname()
part = int(part)
unroll = int(unroll)
if not 'ALADDIN_HOME' in os.environ:
raise Exception('Set ALADDIN_HOME directory as an environment variable')
if not 'TRACER_HOME' in os.environ:
raise Exception('Set TRACER_HOME directory as an environment variable')
if not 'MACH_HOME' in os.environ:
raise Exception('Set MACH_HOME directory as an environment variable')
ALADDIN_HOME = os.getenv('ALADDIN_HOME')
MACH_HOME = os.getenv('MACH_HOME')
if benches == 'all':
benches = main_kernel_c.iterkeys()
else:
benches = benches.split(",")
for bench in benches:
print ""
print '#' * 20
print " %s" % bench
print '#' * 20
kernel = bench.split('-')[0]
algorithm = bench.split('-')[1]
BENCH_HOME = MACH_HOME + '/' + kernel + '/' + algorithm
print BENCH_HOME
os.chdir(BENCH_HOME)
d = 'p%s_u%s_P%s_%sns' % (part, unroll, pipe, clock_period)
#Run LLVM-Tracer to generate the dynamic trace
print bench
source = main_kernel_c[bench]
llvm_compile.main(BENCH_HOME, bench, source)
#Generate accelerator design config file
config.main(BENCH_HOME, kernel, algorithm, part, unroll, pipe, clock_period)
print 'Start Aladdin'
trace_file = BENCH_HOME+ '/' + 'dynamic_trace.gz'
config_file = 'config_' + d
newdir = os.path.join(BENCH_HOME, 'sim', d)
print 'Changing directory to %s' % newdir
os.chdir(newdir)
os.system('%s/common/aladdin %s %s %s ' % (os.getenv('ALADDIN_HOME'), bench, trace_file, config_file))
def __init__(self):
self.style = config.main("sampleProject/style.txt")
self.mainConfig = config.main("sampleProject/config.txt")
self.seitendict = config.main("sampleProject/seiten.txt")
self.sprachendict =config.main("sampleProject/sprachen.txt")
self.templates = {
"head" : "head.py",
"navi" : "navi.py",
# "subnavi2" : "subnavi2.py",
"navilang" : "navi_lang.py",
"footer" : "footer.py",
}
def createWidgets(self):
"""Build and show the GUI elements."""
Label(self.master, text=_("Konfigurationsdatei:")).grid(row=0, sticky=E)
self.configfile = Entry(self.master)
self.configfile.grid(columnspan=2, row=0, column=1, sticky=E+W)
self.auswahl = Button(self.master)
self.auswahl.bind("<Button-1>", self.master)
self.auswahl["text"] = "Auswahl"
self.auswahl.grid(row=1, column=1, sticky=E+W)
Label(self.master, text=_("Search path:")).grid(row=3, sticky=E)
self.ooo_path1 = Entry(self.master)
self.ooo_path1.grid(columnspan=2, row=3, column=1, sticky=E+W)
Label(self.master, text=_("Search terms:")).grid(row=4, sticky=E+W)
self.ooo_path2 = Entry(self.master)
self.ooo_path2.grid(columnspan=2, row=4, column=1, sticky=E+W)
Label(self.master, text=_("Mode:")).grid(row=5, sticky=E)
self.ooo_path3 = Entry(self.master)
self.ooo_path3.grid(columnspan=2, row=5, column=1, sticky=E+W)
Label(self.master, text=_("Matches:")).grid(row=7, sticky=N+E)
self.ooo_path5 = Button(self.master, width = 20)
self.ooo_path5.bind("<Button-1>", self.master)
# self.ooo_path5["width"] = 10
self.ooo_path5["text"] = "S T A R T"
self.ooo_path5.grid(columnspan=2, row=6, column=1, sticky=W)
dictc = config.main("config.txt")
liste = []
for element in dictc:
liste.append(element + ":" + dictc[element])
self.ooo_path4 = self.listbox(liste, 100, 7, 1)
def main():
""" This script is called by puppet """
parse_input(sys.argv)
conf = config.main()
# This is because we don't use FQDNs in our current puppet manifests
# Probably want to remove this
node = (sys.argv[1]).split('.')[0]
# Finds the input node
node_info = find_node(conf, node)
# Default the final_node_info to the input node
final_node_info = node_info
# Check if the input node has inheritance set
if 'inherit' in node_info:
inheritance = True
while inheritance:
# Finds the node being inherited from
inherit_node_info = find_node(conf, node_info['inherit'])
# Updates the final node enc info by merging inherited and final node enc info recursively
final_node_info['enc'] = merge_dict(inherit_node_info['enc'], final_node_info['enc'])
# Sets the node_info to the inherited node, to recurse through the inherited node's inheritance
node_info = find_node(conf, node_info['inherit'])
# Breaks out of while once a node with no inheritance is found
if 'inherit' not in node_info:
inheritance = False
print yaml.safe_dump(final_node_info['enc'], default_flow_style=False)
def main():
""" This script creates the default node definition """
col = config.main()
cmd_parser = argparse.ArgumentParser(description='Add Default Node To Mongodb ENC')
cmd_parser.add_argument('-a', '--action', dest='puppet_action', choices=['append', 'new'], help='Append Or Recreate Default Node', required=True)
cmd_parser.add_argument('-c', '--class', dest='puppet_classes', help='Can specify multiple classes each with -c', action='append', required=True)
args = cmd_parser.parse_args()
c = {}
col.ensure_index('node', unique=True)
for pclass in args.puppet_classes:
c[pclass] = ''
if args.puppet_action == 'append':
d = { 'node' : 'default', 'enc' : { 'classes': c }}
check = col.find_one({ 'node' : 'default' }, {'node': 1})
if not check:
print "Default Node Doesn't Exist, Please Add It First"
sys.exit(1)
ec = col.find_one({ 'node' : 'default'})
ec['enc']['classes'].update(c)
col.remove({ 'node' : 'default'})
col.insert(ec)
if args.puppet_action == 'new':
d = { 'node' : 'default', 'enc' : { 'classes': c }}
check = col.find_one({ 'node' : 'default' }, {'node': 1})
if check:
col.remove({ 'node' : 'default'})
col.insert(d)
def __init__ (self, paradict):
self.act_id = paradict["act_id"]
self.act_lang = paradict["act_lang"]
self.act_langpath = paradict["act_langpath"]
# self.act_dir = paradict["act_dir"]
self.subnavidict = config.main("sampleProject/subnavi.txt")
configdict = config.main("sampleProject/config.txt")
langstring = configdict["lang"]
self.langlist = langstring.split(",")
self.navidict = config.main("sampleProject/navi.txt")
self.seitendict = config.main("sampleProject/seiten.txt")
self.sprachendict =config.main("sampleProject/sprachen.txt")
self.subnaviID = ""
self.target_id = ""
self.target_file = ""
self.target_dir = ""
def main():
import config
import multiprocessing as mp
(args, config, log) = config.main()
serversocket = createSocket(config)
while True:
(clientsocket, address) = serversocket.accept()
p = mp.Process(target=handleRequest, args=(args, config, clientsocket))
p.start()
p.join()
serversocket.close()
def __init__(self):
self.ARGV_GENALL = False
self.ARGV_GENFILELIST = False
self.ARGV_MKDIR = False
if len(sys.argv) > 1:
for i in range(len(sys.argv)):
if i == "-a":
self.ARGV_GENALL = True
if i == "-f":
self.ARGV_GENFILELIST = True
if i == "-p":
self.ARGV_MKDIR = True
if len(sys.argv) >= 2 and (sys.argv[1] == '--help' or sys.argv[1] == '-h'):
print(_("Usage:") +" generate [-h|--help] " + _("[-a] generate all pages, [-f] generate filelist, [-p] gereate directories"))
sys.exit(1)
self.mainConfig = config.main("sampleProject/config.txt")
self.seitendict = config.main("sampleProject/seiten.txt")
def main():
""" This script removes nodes from mongodb """
col = config.main()
cmd_parser = argparse.ArgumentParser(description='Remove Nodes To Mongodb ENC')
cmd_parser.add_argument('-n', '--node', dest='puppet_node', help='Puppet Node Hostname', required=True)
args = cmd_parser.parse_args()
isinode = col.find_one({ "inherit" : args.puppet_node })
if isinode:
isinode = col.find({ "inherit" : args.puppet_node })
for node in isinode:
print "ERROR: "+args.puppet_node+" is inherited by "+node['node']
else:
col.remove({ 'node' : args.puppet_node})
def secure_initiate(data):
import config
config = config.main()
psfr = open("serverdata.posdata.json", "r")
posdata = json.loads(psfr.read())
psfr.close()
if not data["name"] in posdata:
posdata[data["name"]] = {
"world": config.startworld,
"x": int(config.startX) * 16,
"y": int(config.startY) * 16,
"z": int(config.startZ),
"image": "player-test"
}
psfw = open("serverdata.posdata.json", "w+")
psfw.write(json.dumps(posdata))
psfw.close()
return json.dumps(posdata[data["name"]])
def main(lat, lng):
start_time = time.time()
#Define our connection string
options = config.main()
conn_string = "host='" + options['host'] + "' dbname='" + options[
'db_name'] + "' user='******'db_user'] + "' password='******'db_pass'] + "'"
# print the connection string we will use to connect
print("Connecting to database") # % (conn_string)
# get a connection, if a connect cannot be made an exception will be raised here
conn = psycopg2.connect(conn_string)
# conn.cursor will return a cursor object, you can use this cursor to perform queries
cur = conn.cursor()
lat = float(lat)
lng = float(lng)
print("Connected!\n")
sql = (
"SELECT label, CHAR_LENGTH(label),lng,lat, ST_Distance(geog_def, poi) AS distance_m"
" FROM " + options['db_prefix'] + "road,"
" (select ST_MakePoint(%(lng)f, %(lat)f)::geography as poi) as poi"
" WHERE ST_DWithin(geog_def, poi, 100000)"
" AND CHAR_LENGTH(label) >=6 "
" AND label LIKE '%%+%%' "
" ORDER BY ST_Distance(geog_def, poi)"
" LIMIT 1;" % {
'lat': lat,
'lng': lng
})
print(sql)
cur.execute(sql)
rows = cur.fetchall()
print(time.time() - start_time, "seconds")
if len(rows) == 0:
print("Cannot find closest Distance")
return {'label': '0', 'distance': '0'}
else:
for row in rows:
# convert label STA or - to KM
km = label.main(row[0])
print("\nGet Closest Distance:", km['km'])
return {'label': str(km['km']), 'distance': round(row[4], 2)}
def main():
#Define our connection string
options = config.main()
conn_string = "host='" + options['host'] + "' dbname='" + options['db_name'] + "' user='******'db_user'] + "' password='******'db_pass'] + "'"
# print the connection string we will use to connect
print("Connecting to database\n ->%s") # % (conn_string)
# get a connection, if a connect cannot be made an exception will be raised here
conn = psycopg2.connect(conn_string)
# conn.cursor will return a cursor object, you can use this cursor to perform queries
cur = conn.cursor()
print("Connected!\n")
cur.execute("SELECT username from tcm_user")
rows = cur.fetchall()
print("\nShow me the databases:\n")
for row in rows:
print (row[0])
def main():
#Define our connection string
options = config.main()
conn_string = "host='" + options['host'] + "' dbname='" + options[
'db_name'] + "' user='******'db_user'] + "' password='******'db_pass'] + "'"
# print the connection string we will use to connect
print("Connecting to database\n ->%s") # % (conn_string)
# get a connection, if a connect cannot be made an exception will be raised here
conn = psycopg2.connect(conn_string)
# conn.cursor will return a cursor object, you can use this cursor to perform queries
cur = conn.cursor()
print("Connected!\n")
cur.execute("SELECT username from tcm_user")
rows = cur.fetchall()
print("\nShow me the databases:\n")
for row in rows:
print(row[0])
def main():
""" This script is called by puppet """
if (len(sys.argv) < 2):
print "ERROR: Please Supply A Hostname or FQDN"
sys.exit(1)
col = config.main()
# Probably want to remove this. This is because I don't use FQDNs in my current puppet manifest.
# also made this easier for me to test.
node = sys.argv[1]
#node = node.split('.')[0]
# Find the node given at a command line argument
d = col.find_one({"node": node})
if d == None:
print "ERROR: Node "+node+" Not Found In ENC"
sys.exit(1)
# Check if the node requiers inheritance
n = col.find_one({"node": node})
if 'inherit' in n:
i = True
while i == True:
inode = n['inherit']
if not col.find_one({"node" : inode}):
print "ERROR: Inheritance Node "+inode+" Not Found In ENC"
sys.exit(1)
idict = col.find_one({"node": inode})
if 'classes' in idict['enc']:
iclass = idict['enc']['classes']
if 'classes' in n['enc']:
d['enc']['classes'].update(iclass)
else:
d['enc']['classes'] = iclass
n = col.find_one({"node": inode})
if 'inherit' not in n:
i = False
print yaml.safe_dump(d['enc'], default_flow_style=False)
def convUtcTime(date, time):
options = config.main()
utc = pytz.utc
utc = timezone('Etc/Greenwich')
tzname = timezone(options['tzname'])
fmt = '%Y-%m-%d %H:%M:%S %Z%z'
dfmt = '%Y-%m-%d'
tfmt = '%H:%M:%S%z'
yearTwo = str(20)
yearLastTwo = date[4:6]
year = yearTwo+yearLastTwo
month = date[2:4]
day = date[0:2]
hour = time[0:2]
minute = time[2:4]
second = time[4:6]
#datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
input_dt = utc.localize(datetime(int(year), int(month), int(day), int(hour), int(minute), int(second)))
kal_dt = input_dt.astimezone(tzname)
print(kal_dt.strftime(fmt))
#print(date, time)
return {'date' : kal_dt.strftime(dfmt) ,'time' : kal_dt.strftime(tfmt),
'date_utc' : input_dt.strftime(dfmt), 'time_utc' : input_dt.strftime(tfmt)}
from config import main
if __name__ == "__main__":
main()
install_env = os.environ.copy(),
)
update.run_tests()
print update.run_tests.output
################################################################################
opt_parser = optparse.OptionParser()
opt_parser.add_option('-c', '--config', action = 'store_true')
opt_parser.add_option('-s', '--skip_svn', action = 'store_true')
opt_parser.add_option('-f', '--force_build', action = 'store_true')
opt_parser.add_option('-t', '--test', action = 'store_true')
if __name__ == '__main__':
options, args = opt_parser.parse_args()
sys.argv = sys.argv[:1] + args
if options.skip_svn: skip_svn()
if options.force_build: force_build()
if options.test:
run_tests()
else:
# Swap out some slow components for quick debugging
if options.config: config.main()
else: update.main()
################################################################################
# Echo client program
import socket
from urllib.request import Request, urlopen
from urllib import parse,error
import nmea_conv
import time
import distance
import sys
import config
options = config.main()
HOST = options['host'] # The remote host
PORT = 15000 # The same port as used by the server
url_parse = options['base_url'] + '/packet' # Parse Packet Data to php and insert to database
url = options['nodejs_url'] + "/?%s"
#parse_test = parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
#sys.exit(0)
# Get Data from SQL
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send(b'Hello, world')
# test using dict
while True:
listen = s.recv(1024)
line = repr(listen.decode('utf-8', 'ignore'))
if line:
line = line.replace("'", "")
#sys.exit(0)
SITE_ROOT = os.path.dirname(os.path.realpath(__file__))
print("example 1: "+SITE_ROOT)
PARENT_ROOT=os.path.abspath(os.path.join(SITE_ROOT, os.pardir))
print("example 2: "+PARENT_ROOT)
GRANDPAPA_ROOT=os.path.abspath(os.path.join(PARENT_ROOT, os.pardir))
print("example 3: "+GRANDPAPA_ROOT)
#print("This file directory only")
#full_path = os.path.realpath(__file__)
#dir_path = os.path.dirname(full_path)
#sys.path.append(dir_path)
#print(os.path.dirname(full_path))
#sys.exit(0)
option = config.main()
print(option['db_name'])
print("round(80.33956, 2) : ", round(-0.57986588888, 6))
lng = 115.719
lat = -0.493033
knots = 30.2
kmh = nmea_conv.convKnots(knots)
print(kmh)
#sys.exit(0)
data = '1,2,3';
x , y,z = data.split(',')
print(x)
km = label.main('STA 29+000')
print(km['km'])
d =distance.main(lat,lng)
import socket
from urllib.request import Request, urlopen
from urllib import parse, error
import nmea_conv
import time
import distance
import sys
import config
from _symtable import LOCAL
print('connected fleet', sys.argv, ' arguments')
options = config.main() # get config ini
HOST = options['host'] # The remote host
PORT = 15000 # The same port as used by the server
url_parse = options[
'base_url'] + '/packet' # Parse Packet Data to php and insert to database
url = options['nodejs_url'] + "/?%s"
#parse_test = parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
#sys.exit(0)
# Get Data from SQL
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send(b'Hello, world')
# test using dict
while True:
listen = s.recv(1024)
line = repr(listen.decode('utf-8', 'ignore'))
wikifeat_home = input("Enter the Wikifeat installation directory(" + wf_home_default + "): ")
if wikifeat_home == "":
wikifeat_home = wf_home_default
if couchdb_server == "":
couchdb_server = "localhost"
if couchdb_port == "":
couchdb_port = "5984"
domain_name = input("Now, enter the domain/host name for your Wikifeat installation (localhost): ")
if domain_name == "":
domain_name = "localhost"
main_db = "wikifeat_main_db"
avatar_db = "user_avatars"
couch_params = util.CouchParameters()
couch_params.host = couchdb_server
couch_params.port = couchdb_port
couch_params.adminuser = couchdb_admin
couch_params.adminpass = couchdb_admin_pass
master_params = util.MasterUserParameters()
print("Running database setup...")
setup.main(couch_params, main_db, avatar_db, master_params, wikifeat_home)
print("")
print("Configuring Wikifeat...")
config.main(domain_name, couch_params, wikifeat_home)
import time
from datetime import datetime
import itertools
import signal
import numpy as np
import torch
import sys
import config
version = '1.2'
# Gather all configuration parameters from config.py, according to the command-line arguments.
(obj_function_name, n, k, M, Rmin, Rmax, q, xi, Gmax, N, H, EPSILON,
MAX_RECORD_SIZE, var_threshold, tol_threshold, num_runs, scalarizer,
flag_create_snapshots) = config.main(version, sys.argv[1:])
if torch.__version__[0] < '1':
print(
'\nUnsupported PyTorch version. Please upgrade to PyTorch v1.0 or greater.'
)
quit()
flag_jit_enabled = True if (torch.__version__[0] >= '1') else False
torch.set_num_threads(4)
dtype = torch.float32
dtype_int = torch.int32
# Used during calculation of standard deviations
std_dev_coefficient = torch.as_tensor(xi / (N - 1), dtype=dtype)
# Used in the VADS scalarizer function.
def main(kernel,
functions,
size,
part,
unroll,
unroll_inner,
pipe,
clock_period,
compile_kernel,
generalized_trace=0):
if not 'ALADDIN_HOME' in os.environ:
raise Exception(
'Set ALADDIN_HOME directory as an environment variable')
if not 'TRACER_HOME' in os.environ:
raise Exception('Set TRACER_HOME directory as an environment variable')
if not 'GEN_PASS_HOME' in os.environ:
raise Exception(
'Set GEN_PASS_HOME directory as an environment variable')
ALADDIN_HOME = os.getenv('ALADDIN_HOME')
BENCH_HOME = ALADDIN_HOME + '/SHOC/' + kernel
os.chdir(BENCH_HOME)
d = 'p%s_u%s_ui%s_P%s_%sns' % (part, unroll, unroll_inner, pipe,
clock_period)
print d, compile_kernel, generalized_trace
#Run LLVM-Tracer to generate the dynamic trace
#Only need to run once to generate the design space of each algorithm
#All the Aladdin runs use the same trace
if compile_kernel == "True":
llvm_compile.main(BENCH_HOME, kernel, size)
#Generate accelerator design config file
config.main(BENCH_HOME, kernel, size, part, unroll, unroll_inner, pipe,
clock_period, generalized_trace)
for target_func in functions:
print 'Start Aladdin'
trace_file = ''
aladdin_exec = ''
if generalized_trace:
trace_file = BENCH_HOME + '/' + 'generalized_trace-' + target_func + '.gz'
aladdin_exec = 'aladdin-generalized'
else:
trace_file = BENCH_HOME + '/' + 'dynamic_trace-' + target_func + '.gz'
aladdin_exec = 'aladdin'
config_file = 'config_' + d
if generalized_trace:
newdir = os.path.join(BENCH_HOME, 'sim-general-%s' % size, d)
else:
newdir = os.path.join(BENCH_HOME, 'sim-%s' % size, d)
print 'Changing directory to %s' % newdir
os.chdir(newdir)
exec_cmd = ('%s/common/%s %s %s %s' % \
(os.getenv('ALADDIN_HOME'), aladdin_exec, kernel+'-'+target_func, trace_file, config_file))
print(exec_cmd)
os.system(exec_cmd)
if create_graphs:
for file in os.listdir("."):
if file.endswith(".dot"):
base = file[0:-4]
graph_cmd = 'dot -Tpdf -o %s.pdf %s' % (base, file)
print graph_cmd
os.system(graph_cmd)
def main():
# Run after the tests!
config.main()
gui_r.run_gui()
#sanity check for any arguments
if len(sys.argv) == 1:
if sys.version_info[0] >= 3:
reply = input('\nNo Arguments Given, Perform Default Install? [Y/n]')
else:
reply = raw_input(
'\nNo Arguments Given, Perform Default Install? [Y/n]')
if not reply or reply[0].lower() != 'n':
sys.argv.append('install')
#make sure there is a Setup file
if not os.path.isfile('Setup'):
print('\n\nWARNING, No "Setup" File Exists, Running "config.py"')
import config
config.main()
print('\nContinuing With "setup.py"')
try:
s_mtime = os.stat("Setup")[stat.ST_MTIME]
sin_mtime = os.stat("Setup.in")[stat.ST_MTIME]
if sin_mtime > s_mtime:
print('\n\nWARNING, "Setup.in" newer than "Setup",'
'you might need to modify "Setup".')
except:
pass
# get compile info for all extensions
try:
extensions = read_setup_file('Setup')
except:
import socket
from urllib.request import Request, urlopen
from urllib import parse,error
import nmea_conv
import time
import distance
import sys
import config
from _symtable import LOCAL
print('connected fleet' , sys.argv, ' arguments')
options = config.main() # get config ini
HOST = options['host'] # The remote host
PORT = 15000 # The same port as used by the server
url_parse = options['base_url'] + '/packet' # Parse Packet Data to php and insert to database
url = options['nodejs_url'] + "/?%s"
#parse_test = parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
#sys.exit(0)
# Get Data from SQL
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send(b'Hello, world')
# test using dict
while True:
listen = s.recv(1024)
line = repr(listen.decode('utf-8', 'ignore'))
if line:
name = name.replace("/", "")
name = name.replace(" ", "_")
os.mkdir(name)
call(['cp', 'Base_Code/config.py', name + "/config.py"])
call(['cp', 'Base_Code/automate.py', name + "/automate.py"])
call(['cp', 'Base_Code/classify_men.py', name + "/classify_men.py"])
call(['cp', 'Base_Code/classify_women.py', name + "/classify_women.py"])
call([
'cp', 'Base_Code/generate_craigslist.py',
name + "/generate_craigslist.py"
])
call(['cp', 'Base_Code/link_scrap.py', name + "/link_scrap.py"])
call(['cp', 'Base_Code/phone_analysis.py', name + "/phone_analysis.py"])
call(['cp', 'Base_Code/posts_over_time.py', name + "/posts_over_time.py"])
call(
['cp', 'Base_Code/recursive_scrape.py', name + "/recursive_scrape.py"])
call([
'cp', 'Base_Code/results_filter_men.py',
name + "/results_filter_women.py"
])
call(['cp', 'Base_Code/hash_scrap.py', name + "/hash_scrap.py"])
call([
'cp', 'Base_Code/recursive_generate.py',
name + "/recursive_generate.py"
])
os.chdir(name)
config.main(url)
os.chdir("../")
def main(paradict, snkey):
act_lang = paradict["act_lang"]
act_id = paradict["act_id"]
act_langpath = paradict["act_langpath"]
target_id = ""
target_file = ""
target_dir = ""
navi_text = ""
navi_target = ""
subnavikey = ""
"""Subnavigation"""
subnavidict = config.main("subnavi.txt")
seitendict = config.main("seiten.txt")
sprachendict =config.main("sprachen.txt")
subnaviContent = ""
for key in subnavidict:
keysplit = key.split("-")
if keysplit[0] == act_lang:
subnavi = keysplit[1]
if subnavidict[key] == act_id or subnavi == act_id:
subnavikey = keysplit[0] + "-" + keysplit[1]
break
subnavilist = []
for element in subnavidict:
elementSplitlist = element.split("-")
if elementSplitlist[0]+ "-" + elementSplitlist[1] == subnavikey:
subnavilist.append(int(elementSplitlist[2]))
subnavilist.sort()
newsubnavilist = []
for number in subnavilist:
newsubnavilist.append(subnavikey + "-" + str(number))
subnavilist = newsubnavilist
for entry in subnavilist:
if subnavidict[entry] == snkey:
# Subnavigation schreiben
target_id = "Sites" + str(subnavidict[entry])
target_file = seitendict[target_id + "-" + act_lang + "-datei"]
target_dir = seitendict[target_id + "-" + act_lang + "-ordner"]
navi_text = seitendict[target_id + "-" + act_lang + "-text"]
navi_target = "/" + act_langpath + target_dir
if target_file != "index.html":
navi_target += target_file
if target_file != "":
if ("Sites" + str(act_id)) == target_id:
subnaviContent = ' <li class="here">' + navi_text + '</li>\n'
else:
subnaviContent = ' <li><a href="' + navi_target + '">' + navi_text + "</a></li>\n"
return subnaviContent
def dibujar():
config_dicc, palabras_dicc, _ = config.cargar_configuracion()
palabras_lista = config.obtener_lista_palabras(config_dicc)
fuente = config_dicc['fuente']
colores_celda = config.colores(config_dicc)
color_fondo = colores_celda['fondo']
#Colores marcas
color_celda_marcada = colores_celda['marcada']
color_marca = {
None: colores_celda[None],
'adj': ('#262730', config_dicc['color_pincel']['adj']),
'verb': ('#262730', config_dicc['color_pincel']['verb']),
'sust': ('#262730', config_dicc['color_pincel']['sust']),
'Erroneas': colores_celda['Erroneas'],
'MIXTO': colores_celda['MIXTO']
}
color_celda_default = colores_celda['default']
# ~ print('Cargo en dibujar()',config_dicc['orientacion'])
print('Creo lista de palabras random en dibujar()')
print('palabras_lista =', palabras_lista)
## Defino el ancho de la grilla como el mayor entre la cantidad de palabras o la palabra mas larga
ANCHO = max(
len(max(palabras_lista, key=len)), len(palabras_lista)
) # key = len hace que sea por cantidad de char y no alfabéticamente
## O solo la palabra más larga
#ANCHO = len(max(palabras_lista, key=len))
## Y si quiero puede ser cuadrada
ALTO = ANCHO
## Crear la matriz de elementos y llenarla con las letras
matriz = crear_grilla(palabras_lista)
def ayuda(palabras_lista, palabras_dicc, config_dicc):
"""depende de lo recibido en la configuracion de ayuda modifica el layout para que informe lo correspondiente a cada caso"""
""" ayuda_layout lista creada para agregarlo al frame al layout de la sopa"""
# cantv, cantadj, cantsust = cantidad_pal(palabras_dicc)
ayuda_layout = []
if config_dicc['ayuda'] == 'sin ayuda':
column1 = [[
sg.T('Total de palabras a buscar: ' + str(len(palabras_lista)),
justification='center')
], [sg.T('Sustantivos: ' + str(config_dicc['max_sust']))],
[sg.T('Verbos: ' + str(config_dicc['max_verb']))],
[sg.T('Adjetivos: ' + str(config_dicc['max_adj']))]]
ayuda_layout = [[sg.Column(column1)]]
# si es definiciones agrega al layout un numero para la palabra y su descripcion.
# 'palabra num-'+str(j) : asigna un numero a la palabra para mostrar en layout.
# palabras_dicc[palabras_lista[j]]['def'] : accese a la descripcion de la palabra a la que referencia el numero para informar.
# para referenciado por numero toma la posicion en la lista de palabras.
elif config_dicc['ayuda'] == 'definiciones':
column1 = [[
sg.T('-' + str(j) + ': ' +
palabras_dicc[palabras_lista[j]]['def'],
auto_size_text=True)
] for j in range(len(palabras_lista))]
ayuda_layout = [[sg.T('Definiciones: ')], [sg.Column(column1)]]
elif config_dicc['ayuda'] == 'palabras':
column1 = [ ## agrego que el color aparezca en modo fácil, buscar el tipo en el dicc de colores, el segundo elemento porque es una tupla (texto, fondo)
[
sg.T(palabras_lista[j],
background_color=color_marca[palabras_dicc[
palabras_lista[j]]['tipo']][1])
] for j in range(len(palabras_lista))
]
ayuda_layout = [[sg.T('Palabras a buscar :')],
[sg.Column(column1)]]
return ayuda_layout
ayuda_layout = ayuda(palabras_lista, palabras_dicc, config_dicc)
print('ANCHO:', ANCHO, 'Alto:', ALTO)
menu_princ = [[
'&Archivo',
[
'&Cargar...::Menu', '&Guardar...::Menu', '---',
'Configuración::Menu', 'E&xit::Menu'
]
], ['&Ayuda', ['Como jugar?::Menu', 'Acerca de...::Menu']]]
sopa_layout = [[
sg.Button(matriz.celdas[j][i]['letra'],
button_color=color_celda_default,
size=(4, 2),
pad=(0, 0),
font=fuente,
key=str(j) + '_' + str(i)) for i in range(ANCHO)
] for j in range(ALTO)]
size_pincel = (7, 2)
pincel_layout = [[
sg.Text('Adj',
size=size_pincel,
auto_size_text=False,
enable_events=True,
relief='raised',
text_color=color_marca['adj'][0],
background_color=color_marca['adj'][1],
justification='center',
key='adj',
tooltip='Elegir para marcar Adjetivos'),
sg.Text('Verb',
size=size_pincel,
auto_size_text=False,
enable_events=True,
relief='raised',
text_color=color_marca['verb'][0],
background_color=color_marca['verb'][1],
justification='center',
key='verb',
tooltip='Elegir para marcar Verbos'),
sg.Text('Sust',
size=size_pincel,
auto_size_text=False,
enable_events=True,
relief='raised',
text_color=color_marca['sust'][0],
background_color=color_marca['sust'][1],
justification='center',
key='sust',
tooltip='Elegir para marcar Sustantivos'),
]]
#Layout principal.
layout = [[sg.Menu(menu_princ)],
[
sg.Frame('Seleccionar tipo de palabra: ', pincel_layout),
sg.Button(
' Comprobar Errores',
pad=((260, 0), None),
key='comprobar errores',
tooltip='Marca con blanco las marcadas erroneamente.')
],
[
sg.Frame('',
sopa_layout,
font=config_dicc['fuente'],
pad=(0, 0)),
sg.Frame('Ayudas: ',
[[sg.Text('Direcciones:', pad=((20, 0), 0))],
[
sg.Button(image_filename='img/' +
config_dicc['orientacion'] + '.png',
image_size=(80, 80),
image_subsample=4,
border_width=0,
pad=((30, 0), (10, 30)),
button_color=color_fondo)
], [sg.Column(ayuda_layout)]])
]]
layout.append([sg.Button('Cerrar', pad=((580, 10), (5, 3)))])
window = sg.Window('Sopa de Letras').Layout(layout)
start_time = time.time()
# ~ def comprobar_victoria(matriz):
# ~ """si seleccionamos boton comprobar victorias marca en blanco todas las letras que hayan sido presionadas erroneamente."""
# ~ """recorre toda la matriz comprobando que las celdas marcadas sean correctas"""
# ~ for j in range(ANCHO):
# ~ for i in range(ALTO):
# ~ if matriz.celdas[j][i]['marcada'] == True:
# ~ if matriz.celdas[j][i]['tipo'] in ('adj','verb','sust','MIXTO'):
# ~ if matriz.celdas[j][i]['color'] != color_marca[matriz.celdas[j][i]['tipo']] and matriz.celdas[j][i]['tipo'] != 'MIXTO':
# ~ window.FindElement(str(j)+'_'+str(i)).Update(button_color = color_marca['Erroneas'])
# ~ matriz.celdas[j][i]['color']= (color_marca['Erroneas'])
# ~ window.Refresh()
# ~ else:
# ~ window.FindElement(str(j)+'_'+str(i)).Update(button_color = color_marca['Erroneas'])
# ~ matriz.celdas[j][i]['color']= (color_marca['Erroneas'])
def Win_Condition(matriz, win, event):
"""primera parte: si seleccionamos boton "comprobar errores" marca en blanco todas las letras que hayan sido presionadas erroneamente."""
"""segunfa parte: si la celda presionada esta marcada la desmarca y le asigna color Default. Sino la marca y le asigna color de celda marcada."""
"""tercera parte: comprueba victoria atravez de un AND. si encuentra una celda que este marcada erroneamente arrastra el False."""
for i in range(ANCHO):
for j in range(ALTO):
if event == "comprobar errores":
if matriz.celdas[j][i]['marcada']: #primera parte
if matriz.celdas[j][i]['tipo'] in ('adj', 'verb',
'sust', 'MIXTO'):
if matriz.celdas[j][i]['color'] != color_marca[
matriz.celdas[j][i]
['tipo']] and matriz.celdas[j][i][
'tipo'] != 'MIXTO':
window.FindElement(
str(j) + '_' + str(i)).Update(
button_color=color_marca['Erroneas'])
matriz.celdas[j][i]['color'] = (
color_marca['Erroneas'])
window.Refresh()
else:
window.FindElement(str(j) + '_' + str(i)).Update(
button_color=color_marca['Erroneas'])
matriz.celdas[j][i]['color'] = (
color_marca['Erroneas'])
if (matriz.celdas[j][i]['key'] == event): #segunda parte
if matriz.celdas[j][i]['marcada']:
matriz.celdas[j][i]['marcada'] = False
color_celda = color_celda_default
else:
matriz.celdas[j][i]['marcada'] = True
color_celda = color_celda_marcada
matriz.celdas[j][i]['color'] = color_celda
window.FindElement(event).Update(button_color=color_celda)
if matriz.celdas[j][i]['tipo'] != None: #tercera parte
if matriz.celdas[j][i]['tipo'] == 'MIXTO':
win *= matriz.celdas[j][i]['marcada']
else:
win *= matriz.celdas[j][i]['color'] == color_marca[
matriz.celdas[j][i]['tipo']]
#no pudimos extraer el color de pysimplegui por eso le agregamos una key 'color' a la matriz
else:
win *= not (matriz.celdas[j][i]['marcada'])
return win
def Mensaje_Victoria():
print('\nGanaste!')
x_max, y_max = window.GetScreenDimensions()
for rep in range(5):
margen = 150
x_0, y_0 = random.randrange(x_max - margen -
50), random.randrange(y_max - margen -
50)
# ~ x_0, y_0 = 555,450
sign = random.choice([-1, 1])
v_x = sign * random.randrange(1, 50)
v_y = -1 * random.randrange(10, 30)
# ~ v_x, v_y = 10,10
g = 5
t = 0
rebote = 0
x, y = x_0, y_0
while rebote < 3 and t < 500:
x = x + v_x
v_y = v_y + g
y = y + v_y
rand_col = [
'#' + ''.join(
[random.choice('0123456789ABCDEF') for j in range(6)])
for i in range(4)
]
# ~ print(rand_col)## ['#C7980A', '#F4651F', '#82D8A7', '#CC3A05', '#575E76', '#156943', '#0BD055', '#ACD338']
sg.Popup(
' W I N N E R ',
button_color=(
rand_col[0], rand_col[1]
), # Color of buttons (text_color, background_color)
background_color=rand_col[2], # Color of background
text_color=rand_col[3], # Color of text
# ~ button_type = 'POPUP_BUTTONS_NO_BUTTONS',
auto_close=True, # If True window will automatically close
auto_close_duration=5, # Number of seconds for autoclose
non_blocking=True, # If True returns immediately
line_width=50, # Width of lines in characters
font='Fixedsys', # Font to use for characters
no_titlebar=False, # If True no titlebar will be shown
grab_anywhere=
False, # If True can move window by grabbing anywhere
keep_on_top=
True, # If True window will be on top of other windows
location=(x, y) # (x,y) coordinates to show the window
)
if x < 5:
v_x = -1 * v_x
if y < 5:
v_y = -1 * v_y
if x > x_max - margen:
v_x = -1 * v_x
if y > y_max - margen:
rebote += 1
v_y = -1 * v_y
t += 1
elapsed_time = time.time() - start_time
elapsed_time = time.strftime("%H:%M:%S", time.gmtime(elapsed_time))
playsound('mlg-airhorn.mp3')
sg.Popup('¡¡GANASTE!!\nTiempo: ' + elapsed_time,
font='Fixedsys',
keep_on_top=True)
while True: # Event Loop
event, val = window.Read()
win = True
if event is None or event == 'Cerrar' or event == 'Exit::Menu':
break
if event == 'Guardar...::Menu':
filename = 'savegame.sav'
print('Guardo en ', filename)
window.SaveToDisk(filename)
if event == 'Cargar...::Menu':
filename = 'savegame.sav'
print('Cargar ', filename)
window.LoadFromDisk(filename)
if event == 'Configuración::Menu':
config.disable(window)
if sg.PopupOKCancel(
'Perderá el progreso del juego, continuar?') == 'OK':
window.Hide()
config.main()
break
config.enable(window)
if event == 'Como jugar?::Menu':
config.disable(window)
sg.Popup(HOWTO, font='System', keep_on_top=True)
config.enable(window)
if event == 'Acerca de...::Menu':
config.disable(window)
sg.Popup(CREDITS, font='System', keep_on_top=True)
config.enable(window)
if event == 'comprobar errores':
Win_Condition(matriz, win, event)
if event in ('adj', 'verb', 'sust'): # Si toco el pincel
color_celda_marcada = color_marca[event]
for element in ('adj', 'verb', 'sust'):
window.FindElement(element).Update(value=element)
window.FindElement(event).Update(value='* ' + event.upper() + ' *')
win = Win_Condition(matriz, win, event)
if win:
#sg.Popup('¡¡GANASTE!!')
Mensaje_Victoria()
print(event)
window.Close()
def main(argv):
# Base command-line
cmdline = 'docker run'
import argparse
parser = argparse.ArgumentParser(description='Interface for Docker containers.')
parser.add_argument('-w','--io',dest='io_dir',default=None,
help='host directory to use for files I/O with container')
parser.add_argument('-x',dest='with_x11',action='store_true',
help='route x11 from the container?')
parser.add_argument('-d', dest='detached', action='store_true',
help='runs non-interactively (detached mode)')
# parser.add_argument('-f','--file',dest='filename',
# help='filename (found inside io-dir) to argument the container entrypoint')
parser.add_argument('-n','--dry-run', dest='dry_run', action='store_true',
help="don't run the container, just print the command-line instead")
parser.add_argument('-l','--list', dest='list', action='store_true',
help='print preset list of images')
args = parser.parse_known_args()
args = args[0]
if args.list:
print 'List of available/preset images:'
for im in available_configs():
print '- {}'.format(im)
return os.EX_CONFIG
parser.add_argument('image', #choices=available_configs(),
help="name of the image to run. See '-l' for a preset list.")
args = parser.parse_known_args()
args = args[0]
# read config (file) for asked image
import config
cfg = config.main(args.image)
out = parse_config_volumes(cfg, parser, cmdline)
if not out:
return os.EX_DATAERR
parser,cmdline = out
# If no IO dir was given, it takes the default one
iodir_cfg = cfg['volumes']['io'] if args.io_dir is None else args.io_dir
iodir_cfg = os.path.abspath(iodir_cfg)
cmdline += ' -v {0}:{1}'.format(iodir_cfg,'/work/io')
# option for accessing the x11
if args.with_x11:
import x11
_x11 = '/tmp/.X11-unix'
_dsp = x11.get_DISPLAY()
cmdline += ' -v {0}:{1} -e DISPLAY={2}'.format(_x11,_x11,_dsp)
# option for port mappings
if len(cfg['ports'].keys()) > 0:
for p_cont,p_host in cfg['ports'].items():
cmdline += ' -p {0}:{1}'.format(p_host,p_cont)
# image name in DockerHub
i_cfg = cfg['main'].get('image')
image = i_cfg if i_cfg is not '' else args.image
cmdline += ' {0}'.format(image)
# if args.filename is not None:
# cmdline += ' {0}'.format(args.filename)
if args.dry_run:
print "#",'-'*(len(cmdline)-1)
print cmdline
print "#",'-'*(len(cmdline)-1)
else:
import shlex, subprocess
cmdline = shlex.split(cmdline)
p = subprocess.Popen( cmdline,
stdout=sys.stdout,
stderr=sys.stderr)
pid = p.pid
print "#",'-*-'*len(cmdline)
print "Container '{}' from image {} is running".format('nameit',image)
print "The parent's PID is: {}".format(pid)
print "#",'-*-'*len(cmdline)
return os.EX_OK
)
update.run_tests()
print update.run_tests.output
################################################################################
opt_parser = optparse.OptionParser()
opt_parser.add_option('-c', '--config', action='store_true')
opt_parser.add_option('-s', '--skip_svn', action='store_true')
opt_parser.add_option('-f', '--force_build', action='store_true')
opt_parser.add_option('-t', '--test', action='store_true')
if __name__ == '__main__':
options, args = opt_parser.parse_args()
sys.argv = sys.argv[:1] + args
if options.skip_svn: skip_svn()
if options.force_build: force_build()
if options.test:
run_tests()
else:
# Swap out some slow components for quick debugging
if options.config: config.main()
else: update.main()
################################################################################
def subContent(self):
target = self.Site_languagepath + self.Site_actpath + self.Site_file
act_id = self.Site_siteid
act_lang = self.Site_language
act_lang_path = self.Site_languagepath
key = self.Site_siteid + "-" + self.Site_language + "-" + "script"
if key in self.seitendict:
script = self.seitendict[key]
else:
script = ""
ThisContent = ""
linear_navi_code = ""
s = self.Site_siteid + "-" + self.Site_language + "-" + "index_chapter"
if s not in self.seitendict or self.seitendict[s] == "":
linear_navi_code = ' <ul class="linear2">\n'
NaviLinear = {
0 : "next",
1 : "prev",
2 : "index_chapter",
}
for i in range(2):
t = self.Site_siteid + "-" + self.Site_language + "-" + NaviLinear[i]
if t in self.seitendict:
target_id = self.seitendict[t]
else:
target_id = 0
l = "Sites" + str(target_id) + "-" + self.Site_language
if target_id != 0:
link_target = act_lang_path + self.seitendict[l + "-ordner"]
target_file = self.seitendict[l + "-datei"]
if target_file[0:6] != "index.":
link_target += target_file
lexikonDict = config.main("lexikon.txt")
linear_navi_code += ' <li><a href="/' + link_target + '">' + lexikonDict[act_lang] + "-" + NaviLinear[i]
if "gal_navi_text" not in self.Global or self.Global["gal_navi_text"] == "":
linear_navi_code += ": " + self.seitendict[l + "-title"]
linear_navi_code += "</a></li>\n"
linear_navi_code += " </ul>\n"
if ("linear_navi_code" != "" and self.Global['gal_navi_line'] == "top") or self.Global['gal_navi_line'] == "both":
ThisContent += linear_navi_code
if script != "":
if os.path.isfile(self.mainConfig["homepath"] + "/" + script):
script = self.mainConfig["homepath"] + "/" + script
with open(script, "r") as f:
exec(f.read())
elif os.path.isfile(self.mainConfig["globalpath"] + "/" + script):
script = self.mainConfig["globalpath"] + "/" + script
with open(script, "r") as f:
exec(f.read())
else:
print("<br /><em>WARNUNG: In ID " + act_id + " referenziertes Script " + script + " existiert nicht!</em>\n")
self.Content = ''
ThisContent += self.Content
if os.path.isfile(self.mainConfig["templatespath"] + "/" + target):
target = self.mainConfig["templatespath"] + "/" + target
with open(target, "r") as f:
ThisContent += f.read()
else:
print("<br /><em>WARNUNG: Datei " + target + " existiert nicht!</em>\n")
if ThisContent == "":
print("<br /><em>WARNUNG: Inhalt fuer " + self.mainConfig["templatespath"] + "/" + target + " existiert nicht!</em>\n")
if os.path.isfile(self.mainConfig["templatespath"] + "/" + target + ".kontext"):
kontext = self.mainConfig["templatespath"] + "/" + target + ".kontext"
with open(kontext, "r") as f:
ThisContent += f.read()
if ("linear_navi_code" != "" and self.Global['gal_navi_line'] == "bottom") or self.Global['gal_navi_line'] == "both":
ThisContent += linear_navi_code
return ThisContent
import os
import sys
import subprocess
from with_cd import cd
import p4_util
import config
if __name__ == '__main__':
print __file__
print os.system('date')
lxr = '/etc/lxr-2.0.3/lxr.conf'
latest = p4_util.main()
if latest in config.current_versions(lxr):
print 'Config already processed'
sys.exit(0)
config.main(lxr,'/home/lxr/Perforce/main')
with cd('/etc/lxr-2.0.3') as dir:
command = './genxref --url=http://lxr/lxr --allversions'
print command
subprocess.check_call(command, shell=True)
print os.system('date')
coord.request_stop()
coord.join(queue_threads, stop_grace_period_secs=5)
except:
pass
sess.close()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-S', '--model_save_dir', type=str, default='./runs/', help='Path to main model save directory')
parser.add_argument('-M', '--model_id', dest='model_id', type=str, help='Model folder. Set to continue training.')
parser.add_argument('--checkpoint_id', type=str, default=None, help='Log and output directory')
args = parser.parse_args()
if args.model_id is not None:
# Restore
config_dict = json.load(open(os.path.abspath(os.path.join(args.model_save_dir, args.model_id, 'config.json')), 'r'))
# in case folder is renamed.
config_dict['model_dir'] = os.path.join(args.model_save_dir, args.model_id)
config_dict['checkpoint_id'] = args.checkpoint_id
config_dict['model_id'] = args.model_id
else:
# Fresh training
import config
config_dict = config.main()
config_dict['model_dir'] = None
tf.set_random_seed(config_dict['seed'])
train(config_dict)
def main():
""" This script adds nodes to the mongodb enc """
col = config.main()
cmd_parser = argparse.ArgumentParser(description='Add Nodes To Mongodb ENC')
cmd_parser.add_argument('-a', '--action', dest='puppet_action', choices=['append', 'new'], help='Append Or Recreate Default Node', required=True)
cmd_parser.add_argument('-n', '--node', dest='puppet_node', help='Puppet Node Hostname', required=True)
cmd_parser.add_argument('-c', '--class', dest='puppet_classes', help='Can specify multiple classes each with -c', action='append')
cmd_parser.add_argument('-p', '--param', dest='puppet_param', help='Can specify multiple parameters each with -p', action='append')
cmd_parser.add_argument('-i', '--inherit', dest='puppet_inherit', help='Define a node to inherit classes from', action='store', default='default')
cmd_parser.add_argument('-e', '--environment', dest='environment', help='Optional, defaults to "production"', default='production')
args = cmd_parser.parse_args()
if args.puppet_node == args.puppet_inherit != 'default' :
print "ERROR: Node name and inherit name can not be the same"
sys.exit(1)
if args.puppet_classes:
c = {}
for pclass in args.puppet_classes:
c[pclass] = ''
if args.puppet_param:
args.puppet_param = dict([arg.split('=') for arg in args.puppet_param])
if args.puppet_inherit:
ck = col.find_one({ "node" : args.puppet_inherit})
if not ck:
print "ERROR: Inherit node does not exist, please add "+args.puppet_inherit+" and then retry"
sys.exit(1)
if args.puppet_action == 'new':
check = col.find({ 'node' : args.puppet_node }, {'node': 1})
for document in check:
node = document['node']
if node == args.puppet_node:
print args.puppet_node+" Exists In Mongodb. Please Remove Node"
if args.puppet_classes:
d = { 'node' : args.puppet_node, 'enc' : { 'classes': c, 'environment' : args.environment }}
else:
d = { 'node' : args.puppet_node, 'enc' : { 'environment' : args.environment }}
if args.puppet_param:
d['enc']['parameters'] = args.puppet_param
if args.puppet_inherit:
d['inherit'] = args.puppet_inherit
col.ensure_index('node', unique=True)
col.insert(d)
if args.puppet_action == 'append':
node = col.find_one({ 'node' : args.puppet_node})
if node == None:
print "ERROR: Not Node In Mongo ENC. Please Use -a new"
sys.exit(1)
if args.puppet_classes:
if 'classes' in node['enc']:
node['enc']['classes'].update(c)
else:
node['enc']['classes'] = c
c = node['enc']['classes']
col.update({ 'node' : args.puppet_node}, { '$set': { 'enc.classes' : c }})
if args.puppet_param:
if 'parameters' in node['enc']:
node['enc']['parameters'].update(args.puppet_param)
else:
node['enc']['parameters'] = args.puppet_param
p = node['enc']['parameters']
col.update({ 'node' : args.puppet_node}, { '$set': {'enc.parameters' : p}})
if args.puppet_inherit:
node['enc']['inherit'] = args.puppet_inherit
col.update({ 'node' : args.puppet_node}, { '$set' : {'inherit' : args.puppet_inherit}})
def run_config(sin):
import config
config.main(sin)
def main():
args = get_arguments()
config.main()
static.main(args)
static.set_static_variable()
def generatePages(self):
pageCounter = 0
file_list = ""
print("\n<p>Seiten werden geschrieben:\n")
for Site in self.seitendict:
urlPartAr = Site.split("-")
Site_siteid = urlPartAr[0]
Site_siteid = Site_siteid.replace("Sites", "")
Site_language = urlPartAr[1]
Site_languagepath = config.main("sampleProject/sprachen.txt")[urlPartAr[1] + "-pfad"]
Site_actpath = self.seitendict[urlPartAr[0] +"-" + urlPartAr[1] + "-ordner"]
Site_file = self.seitendict[urlPartAr[0] +"-" + urlPartAr[1] + "-datei"]
if Site_file != "":
if Site_languagepath[-1:] != "" and Site_languagepath[-1:] != "/":
Site_languagepath = Site_languagepath + "/"
if Site_actpath[-1:] != "" and Site_actpath[-1:] != "/":
Site_actpath = Site_actpath + "/"
Site_target = Site_languagepath + Site_actpath + Site_file
Funktionen = functions.Funktionen()
Funktionen.setGlobals(Site_siteid,Site_language,Site_languagepath,Site_actpath,Site_file)
ThisSite = Funktionen.mkHead() + self.IndexTemplate
i = 0
while ThisSite.find("@@@") >= 0:
ThisSite = Funktionen.subTemplates(ThisSite)
Target = self.mainConfig["docrootpath"] + "/" + Site_target
if self.ARGV_MKDIR and not os.path.exists(self.mainConfig["docrootpath"] + Site_languagepath + Site_actpath):
Meldung = Funktionen.myMkDir(self.mainConfig["docrootpath"] + Site_languagepath + Site_actpath)
print(Meldung)
try:
with open(Target, "r") as f:
myOrig = f.read()
except:
myOrig = ""
if (myOrig != ThisSite) or self.ARGV_GENALL:
try:
with open(Target, "w") as f:
f.write(ThisSite)
except:
print("<p>error writing file: " + Target + "</p>\n")
print("ThisSite: " + ThisSite)
if self.ARGV_GENFILELIST:
file_list += "Target "
print(".")
pageCounter += 1
print("\n<br />"+ str(pageCounter) + " Seiten wurden geschrieben.</p>\n")
if len(file_list) > 0:
print("FILELIST: " + str(file_list) + "\n")
#sanity check for any arguments
if len(sys.argv) == 1:
if sys.version_info[0] >= 3:
reply = input('\nNo Arguments Given, Perform Default Install? [Y/n]')
else:
reply = raw_input('\nNo Arguments Given, Perform Default Install? [Y/n]')
if not reply or reply[0].lower() != 'n':
sys.argv.append('install')
#make sure there is a Setup file
if not os.path.isfile('Setup'):
print ('\n\nWARNING, No "Setup" File Exists, Running "config.py"')
import config
config.main()
print ('\nContinuing With "setup.py"')
try:
s_mtime = os.stat("Setup")[stat.ST_MTIME]
sin_mtime = os.stat("Setup.in")[stat.ST_MTIME]
if sin_mtime > s_mtime:
print ('\n\nWARNING, "Setup.in" newer than "Setup",'
'you might need to modify "Setup".')
except:
pass
# get compile info for all extensions
try:
extensions = read_setup_file('Setup')
if couchdb_admin_pass == "":
print("You must specify a CouchDB admin password!")
sys.exit(-1)
if couchdb_server == "":
couchdb_server = "localhost"
if couchdb_port == "":
couchdb_port = "5984"
domain_name = input("Now, enter the domain/host name for your Wikifeat installation (localhost): ")
if domain_name == "":
domain_name = "localhost"
main_db = "wikifeat_main_db"
avatar_db = "user_avatars"
couch_params = util.CouchParameters()
couch_params.host = couchdb_server
couch_params.port = couchdb_port
couch_params.adminuser = couchdb_admin
couch_params.adminpass = couchdb_admin_pass
master_params = util.MasterUserParameters()
print("Running database setup...")
setup.main(couch_params, main_db, avatar_db, master_params)
print("")
print("Configuring Wikifeat...")
config.main(domain_name, couch_params)
