def main():
parse_command_line()
db.load()
atexit.register(db.save)
app = tornado.web.Application(
[
(r"/login", LoginHandler),
(r"/register", RegisterHandler),
(r"/refresh", RefreshHandler),
(r"/userlist", UserListHandler),
(r"/mkroom", MakeRoomHandler),
(r"/roominfo", RoomInfoHandler),
(r"/getmsg", GetMessageHandler),
(r"/sendmsg", SendMessageHandler),
(r"/getfile", GetFileHandler),
(r"/sendfile", SendFileHandler),
(r"/save", SaveHandler),
],
debug=options.debug,
)
app.listen(options.port)
check_logout_loop = tornado.ioloop.PeriodicCallback(
db.check_logout, 1000 * options.check_interval)
check_logout_loop.start()
tornado.ioloop.IOLoop.instance().start()
def __init__(self):
# default channel is latest scan
self.channel = None
self.labels = None
self.signal_measurements = ["snq", "ss", "seq"]
self.default_antenna = load("SELECT configured_antenna_instance FROM monitor")["configured_antenna_instance"].to_list()[0]
self.default_channel = load("""SELECT channel FROM mapping WHERE channel IN (SELECT DISTINCT channel FROM signal
INNER JOIN scan ON signal.scan_instance = scan.scan_instance WHERE antenna_instance=?
AND snq>0) ORDER BY channel ASC LIMIT 1""", self.default_antenna)["channel"].values.tolist()[0]
antenna_df = load("SELECT * FROM antenna")
self.antenna_map = {instance: {"name": str(instance) + "; " + "Name: " + name + ", Location: " + location + ", Direction: " + str(direction) + " degrees, Comments: "}
for instance, name, location, direction, comment in zip(antenna_df["antenna_instance"], antenna_df["name"], antenna_df["location"],
antenna_df["direction"], antenna_df["comment"])}
# Remove quotations
for i, description in enumerate(self.antenna_map.values()):
if "'" in self.antenna_map[i + 1]["name"]:
self.antenna_map[i + 1]["name"] = self.antenna_map[i + 1]["name"].replace("'", "")
if "\"" in self.antenna_map[i + 1]["name"]:
self.antenna_map[i + 1]["name"] = self.antenna_map[i + 1]["name"].replace("\"", "")
self.weather_map = {
self.default_antenna:
load("""SELECT DISTINCT(status) FROM weather INNER JOIN
scan ON weather.start_time = scan.start_time WHERE
antenna_instance=?""", self.default_antenna)["status"].values.tolist()
}
self.filter_col_labels = ["hour_of_day", "weather.start_time", "temperature", "wind_direction", "wind_speed", "humidity", "status"]
self.max_filter_conditions = 7
def test_dump_load(self) :
db.dump(t,'test.db')
t2=tr.Tree()
db.load(t2,'test.db')
a=t.traverse('')
b=t2.traverse('')
self.assertItemsEqual(a,b)
def __init__(self):
# default scan is latest scan
self.scan = None
self.labels = None
self.default_antenna = load(
"SELECT configured_antenna_instance FROM monitor"
)["configured_antenna_instance"].to_list()[0]
antenna_df = load("SELECT * FROM antenna")
self.antenna_map = {
instance: {
"name":
str(instance) + "; " + "Name: " + name + ", Location: " +
location + ", Direction: " + str(direction) +
" degrees, Comments: "
}
for instance, name, location, direction, comment in zip(
antenna_df["antenna_instance"], antenna_df["name"],
antenna_df["location"], antenna_df["direction"],
antenna_df["comment"])
}
# Remove quotations
for i, description in enumerate(self.antenna_map.values()):
if "'" in self.antenna_map[i + 1]["name"]:
self.antenna_map[i + 1]["name"] = self.antenna_map[
i + 1]["name"].replace("'", "")
if "\"" in self.antenna_map[i + 1]["name"]:
self.antenna_map[i + 1]["name"] = self.antenna_map[
i + 1]["name"].replace("\"", "")
def main():
parse_command_line()
db.load()
atexit.register(db.save)
app = tornado.web.Application(
[
(r"/login", LoginHandler),
(r"/register", RegisterHandler),
(r"/refresh", RefreshHandler),
(r"/userlist", UserListHandler),
(r"/mkroom", MakeRoomHandler),
(r"/roominfo", RoomInfoHandler),
(r"/getmsg", GetMessageHandler),
(r"/sendmsg", SendMessageHandler),
(r"/getfile", GetFileHandler),
(r"/sendfile", SendFileHandler),
(r"/save", SaveHandler),
],
debug=options.debug,
)
app.listen(options.port)
check_logout_loop = tornado.ioloop.PeriodicCallback(
db.check_logout, 1000 * options.check_interval
)
check_logout_loop.start()
tornado.ioloop.IOLoop.instance().start()
def get_json(self, scantime=None, antenna=None):
existing_antennas = load("SELECT antenna_instance FROM antenna"
)["antenna_instance"].tolist()
if antenna not in existing_antennas:
# return figure rendered for last antenna
return plotly.io.to_json(self.fig)
try:
# Sets default and acts as an extra layer of sanitization
int(scantime)
except TypeError:
scantime = "SELECT strftime('%s', 'now')"
df = load(
"""SELECT * FROM scan WHERE antenna_instance=?
ORDER BY ABS(start_time - (?)) LIMIT 1;""", antenna,
scantime)[["scan_instance", "start_time"]]
self.scan = df["scan_instance"].values.tolist()[0]
self.start_time = df["start_time"].values.tolist(
)[0] * 1000 # convert from seconds to miliseconds
self._build_df()
self._build_labels(antenna)
self._graph()
return plotly.io.to_json(self.fig)
def _build_df(self):
signals = pd.DataFrame()
for channel in self.real_channels:
df = load("""SELECT signal.scan_instance, snq, ss, seq
FROM signal LEFT JOIN scan ON signal.scan_instance = scan.scan_instance
WHERE channel=? AND antenna_instance=?""", channel, self.current_antenna)
df.columns = ["scan_instance"] + [f"{measurement}{channel}" for measurement in self.signal_measurements]
signals = pd.merge(signals, df, how="inner", on="scan_instance") if not signals.empty else df
annotationsdf = load("""SELECT status, temperature, wind_direction, wind_speed,
humidity FROM weather LEFT JOIN scan ON scan.start_time =
weather.start_time WHERE antenna_instance=?""", self.current_antenna)
annotationsdf["annotations"] = [
f"""Status: {status}<br>Temp: {str(temp)} F<br>Wind Direction: {str(winddirection)} Degrees<br>Wind Speed: {str(windspeed)} mph<br>Humidity: {str(humidity)}%"""
for status, temp, winddirection, windspeed, humidity in
zip(annotationsdf["status"], annotationsdf["temperature"], annotationsdf["wind_direction"],
annotationsdf["wind_speed"], annotationsdf["humidity"])
]
annotationsdf = annotationsdf.drop(columns=["status", "temperature", "wind_direction", "wind_speed", "humidity"])
scans = load("SELECT scan_instance, datetime(start_time,'unixepoch','-4 hours') as start_time FROM scan")
# scans = scans.rename(columns={"datetime(start_time,'unixepoch','localtime')":"start_time"})
scans = scans.astype({"start_time":"datetime64[ns]"})
self.mdf = pd.merge(signals, scans, how="inner", on=["scan_instance"]) # merged data frame
self.mdf = self.mdf.join(annotationsdf)
def __init__(self):
super().__init__()
self.default_signal_measurement = "snq"
self.signal_measurements = ["snq", "ss", "seq"]
self.colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b",
"#e377c2", "#7f7f7f", "#bcbd22", "#17becf", "goldenrod", "darkseagreen",
"palevioletred", "slateblue", "teal", "chocolate", "deepskyblue", "lightcoral",
"greenyellow", "dodgerblue", "darksalmon", "khaki", "plum", "lightgreen",
"mediumslateblue", "olive", "darkgray", "fuschia", "ivory"]
self.color_cycle = cycle(self.colors)
self.default_antenna = load("SELECT configured_antenna_instance FROM monitor")["configured_antenna_instance"].to_list()[0]
self.current_antenna = self.default_antenna
antenna_df = load("SELECT * FROM antenna")
self.antenna_map = {instance: {"name": str(instance) + "; " + "Name: " + name + ", Location: " + location + ", Direction: " + str(direction) + " degrees, Comments: "}
for instance, name, location, direction, comment in zip(antenna_df["antenna_instance"], antenna_df["name"], antenna_df["location"],
antenna_df["direction"], antenna_df["comment"])}
# Remove quotations
for i, description in enumerate(self.antenna_map.values()):
if "'" in self.antenna_map[i + 1]["name"]:
self.antenna_map[i + 1]["name"] = self.antenna_map[i + 1]["name"].replace("'", "")
if "\"" in self.antenna_map[i + 1]["name"]:
self.antenna_map[i + 1]["name"] = self.antenna_map[i + 1]["name"].replace("\"", "")
self.fig = None
self.real_channels = None
self.labels = None
self.mdf = None
def test_dump_load(self) :
db.dump(t,'test.db')
t2=tr.Tree()
db.load(t2,'test.db')
a=t.traverse('')
b=t2.traverse('')
#print a,b
#b = [unicode(i,'utf-8') for i in b]
self.assertItemsEqual(a,b)
def get_channel_map(self, antenna=None):
existing_antennas = load("SELECT antenna_instance FROM antenna")["antenna_instance"].tolist()
if antenna not in existing_antennas:
antenna = self.default_antenna
channeldf = load("""SELECT DISTINCT channel FROM signal INNER JOIN
scan ON signal.scan_instance = scan.scan_instance
WHERE antenna_instance=? AND snq>0;""", antenna)
self.real_channels = sorted(channeldf["channel"].values.tolist(), reverse=True)
self._build_labels(antenna)
return self.labels
def get_weather_map(self, antenna=None):
existing_antennas = load("SELECT antenna_instance FROM antenna")["antenna_instance"].tolist()
if antenna not in existing_antennas:
antenna = self.default_antenna
self.weather_map = {
antenna:
load("""SELECT DISTINCT(status) FROM weather INNER JOIN
scan ON weather.start_time = scan.start_time WHERE
antenna_instance=?""", antenna)["status"].values.tolist()
}
return self.weather_map
def test_dump():
o = BaseObject('Base')
m = MobObject('Mob')
p = PlayerObject('Player')
r = RoomObject('Room')
db.dump(fname)
l = len(db.objects)
logger.info('Current objects: %s.', db.objects)
db.clear()
assert not len(db.objects)
db.load(fname)
assert len(db.objects) >= l, '%s (%s -> %s).' % (db.objects, len(db.objects), l)
os.remove(fname)
logger.info('Removed DB file: %s.', fname)
def main():
ads = db.load()
if ads == None:
ads = {}
oldadids = set(ads.keys())
newads = crawler.fetch_new_ads(oldadids)
print "[+] Found", len(newads), "new ads"
# this fills ad.copies for all newads
find_duplicates(newads, ads)
for ad in newads.values():
if ads.get(ad.adid) != None:
# make sure we're not accidentally overwriting an old ad
print "[-] AD %s is already in the DB!"%(ad.adid)
continue
ads[ad.adid] = ad
if len(ad.copies) > 0:
print "[+] Ad copy found!", ad.adid, settings.BASEURL + ad.link, ad.copies
else:
print "[+] NEW AD!", ad.adid, ad.link, ad.copies
body = "%s %s\n"%(ad.adid, ad.link)
send_mail([settings.EMAILADDRESS], "root@localhost", "New real-estate", body)
print "Total ads in DB:", len(ads)
db.save(ads)
def load(cls, slug, password):
data = db.load(slug)
if data is None:
return
game_state = GameState(data)
game_state.check_password(password)
return game_state.initialize()
def list_roi():
response.content_type = 'application/json'
roisSaved = db.load()
dataToSend = {}
dataToSend['name']="Rois Saved in SM"
dataToSend['data'] = roisSaved
d = json.dumps(dataToSend)
return (d)
def list_roi():
response.content_type = 'application/json'
roisSaved = db.load()
dataToSend = {}
dataToSend['name']="Rois Saved in SM"
dataToSend['data'] = roisSaved
d = json.dumps(dataToSend)
return (d)
def _build_df(self, channel, antenna, filter_conditions, inversetod):
qstrings = []
qvalues = []
if filter_conditions != None:
if inversetod:
start_splice = 1
qstrings.append(" AND (hour_of_day>=? OR hour_of_day<=?)")
qvalues.extend(filter_conditions["hour_of_day"])
else:
start_splice = 0
for col_label in self.filter_col_labels[start_splice:6]:
new_q = f" AND {col_label}>=? AND {col_label}<=?" if filter_conditions[col_label] else ""
qstrings.append(new_q)
if filter_conditions[col_label]:
qvalues.extend(filter_conditions[col_label])
if filter_conditions["status"] != None:
qstrings.append(" AND status=?")
qvalues.append(filter_conditions["status"])
else:
qstrings = ["" for i in range(self.max_filter_conditions)]
self.df = load(
"""SELECT signal.scan_instance, signal.ss, signal.snq, signal.seq,
scan.antenna_instance, weather.start_time, weather.start_time -
strftime('%s', weather.start_time, "unixepoch", "start of day")
as hour_of_day, weather.reference_time, weather.status,
weather.temperature, weather.wind_direction, weather.status,
weather.temperature, weather.wind_direction, weather.sunset
FROM signal
LEFT JOIN scan ON signal.scan_instance = scan.scan_instance
LEFT JOIN weather ON scan.start_time = weather.start_time
WHERE channel=? AND antenna_instance=?""" + "".join(qstrings),
channel, antenna, *qvalues
)
channeldf = load("""SELECT DISTINCT channel FROM signal INNER JOIN
scan ON signal.scan_instance = scan.scan_instance
WHERE antenna_instance=? AND snq>0;""", antenna)
self.real_channels = sorted(channeldf["channel"].values.tolist(), reverse=True)
def get_antenna_range(self, antenna=None):
existing_antennas = load("SELECT antenna_instance FROM antenna"
)["antenna_instance"].tolist()
if antenna not in existing_antennas:
return
return {
# Factor of 1000 used to convert from seconds to miliseconds
"start":
load(
"SELECT * FROM scan WHERE antenna_instance=? ORDER BY scan_instance ASC LIMIT 1",
antenna)["start_time"].values.tolist()[0] * 1000,
"end":
load(
"SELECT * FROM scan WHERE antenna_instance=? ORDER BY scan_instance DESC LIMIT 1",
antenna)["start_time"].values.tolist()[0] * 1000
}
def __init__(self):
self.num_workers = 10
self.bucket = boto.connect_s3(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY).get_bucket('YOUR_S3_BUCKET')
self.known_ids = {}
self.queue = Queue.Queue()
self.proc_count = 0
self.queue_count = 0
self.tot_proc_time = 0
self.avg_proc_time = 20
self.proc_errors = 0
self.qInfo = {}
self.lock = threading.Lock()
self.startWorkers()
db.load()
def run(fileName):
if fileName is not None:
db.load(fileName)
else:
db.connect(':memory:')
db.createTable()
while not quitRequested:
try:
line = input('> ')
if line == '':
continue
cmd = line.split()
cmds[cmd[0]][0](cmd)
except KeyError:
print(f'{cmd[0]:} is not a command')
except Exception as e:
print(f"{cmd[0]} command failed with '{e:}'")
db.close()
def connect(db_name):
#connect to db
status = db.reconnect(db_name)
#load data
load = db.load()
world_list = getworlds(True)
#fix it so it can be loaded to selectorbox
wlist_fix = []
for world in world_list:
wlist_fix.append([world])
return status, wlist_fix
def _build_labels(self, antenna):
"""Builds graph labels with real and virtual channel numbers
"""
self.labels = {channel: str(channel) + ": " for channel in self.real_channels}
self.mapping = load("""SELECT channel, virtual FROM mapping
WHERE channel IN (SELECT DISTINCT channel
FROM signal INNER JOIN scan ON signal.scan_instance
= scan.scan_instance WHERE antenna_instance=?
AND snq>0)""", antenna)
for real, virtual in zip(self.mapping["channel"].values, self.mapping["virtual"].values):
if real in self.real_channels:
self.labels[real] += ", " + str(virtual)
for channel in self.labels.keys():
self.labels[channel] = self.labels[channel].replace(", ", "", 1)
def get_json(self, antenna=None):
try:
# Sets default and acts as an extra layer of sanitization
int(antenna)
self.current_antenna = antenna
except TypeError:
pass
self.real_channels = load(f"""SELECT DISTINCT channel FROM (SELECT * FROM signal
WHERE signal.scan_instance IN (SELECT scan_instance
FROM scan WHERE antenna_instance={self.current_antenna})) WHERE snq>0;""")["channel"].to_list()
self.real_channels = sorted(self.real_channels, reverse=True)
self._build_labels()
self._build_df()
self._graph()
return plotly.io.to_json(self.fig)
def main_loop():
print('Welcome! What would you like to do?')
name = 'default'
data = db.load(name)
while True:
player_input = input('\nShow entries: 1, Make an entry: 2, Exit: 3.\n')
if player_input == '1':
func.show_log(data)
elif player_input == '2':
func.make_an_entry(data)
elif player_input == '3':
db.save(name, data)
print('Exiting ~~')
time.sleep(1)
return
else:
print('Input invalid. Try again')
def _build_labels(self):
"""Builds graph labels with real and virtual channel numbers
"""
vertical_labels = [str(channel) + "<br>---" for channel in self.real_channels]
horizontal_labels = [str(channel) + " |" for channel in self.real_channels]
self.mapping = load("""SELECT channel, virtual FROM mapping
WHERE channel IN (SELECT DISTINCT channel
FROM signal INNER JOIN scan ON signal.scan_instance
= scan.scan_instance WHERE antenna_instance=?
AND snq>0)""", self.current_antenna)
# Converting virtual channel & station name str to sorted virtual channel float
self.mapping["floatVirtuals"] = pd.Series([float(virtual[0]) for virtual in self.mapping["virtual"].str.split().to_list()])
self.mapping = self.mapping.sort_values(by="floatVirtuals")
for real, virtual in zip(self.mapping["channel"].values, self.mapping["virtual"].values):
if real in self.real_channels:
i = self.real_channels.index(real)
vertical_labels[i] += "<br>" + str(virtual)
horizontal_labels[i] += " " + str(virtual)
self.labels = {channel: {"vertical": vertical + "<br>", "horizontal": horizontal} for (channel, vertical, horizontal) in zip(self.real_channels, vertical_labels, horizontal_labels)}
def _build_labels(self, antenna):
"""Builds graph labels with real and virtual channel numbers
"""
self.labels = [
str(channel) + "<br>---" for channel in self.real_channels
]
self.mapping = load(
"""SELECT channel, virtual FROM mapping
WHERE channel IN (SELECT DISTINCT channel
FROM signal INNER JOIN scan ON signal.scan_instance
= scan.scan_instance WHERE antenna_instance=?
AND snq>0)""", antenna)
# Converting virtual channel & station name str to sorted virtual channel float
self.mapping["virtual"] = pd.Series([
float(virtual[0])
for virtual in self.mapping["virtual"].str.split().to_list()
])
for real, virtual in zip(self.mapping["channel"].values,
self.mapping["virtual"].values):
if real in self.real_channels:
i = self.real_channels.index(real)
self.labels[i] += "<br>" + str(virtual)
def show_score_board():
display.print_XY("", 1, 1)
display.clear_screen()
draw_frame(screen_size[0], screen_size[1])
buff = db.load()
msg = ""
name = "name"
score = "Score"
tmp = screen_size[0] - len(name) - len(score)
msg = name + " " * tmp + score
display.print_XY(msg, 1, 1, "yellow", "blue", "bright")
color = ["green", "red"]
toggle = 1
if (buff[0] != ""):
for i in range(len(buff)):
name, score = buff[i].split(":")
score = score[:-1]
tmp = screen_size[0] - len(name) - len(score)
msg = name + " " * tmp + score
display.print_XY(msg, 1, 2 + i, "white", color[toggle], "bright")
if (toggle == 0):
toggle = 1
else:
toggle = 0
def main():
config = load_config()
reader = make_reader()
sounder = PWM(Pin(4))
network.WLAN(network.AP_IF).active(False) # disable access point
client = network.WLAN(network.STA_IF)
connect(client, config['ssid'], config['password'], sounder)
while True:
try:
if not client.isconnected():
connect(client, config['ssid'], config['password'], sounder)
card_id = read(reader)
if card_id == config['master_card']:
print("master card detected")
program_tracks(reader, sounder, config)
elif card_id == config['pause_card']:
print("pausing")
squeezebox.pause(config['host'], config['port'],
config['player_id'])
speaker.success_sound(sounder)
else:
print("card %s read" % card_id)
data = db.load(card_id)
if data and 'tracks' in data:
print("playing %s" % data['tracks'])
squeezebox.play(config['host'], config['port'],
config['player_id'], data['tracks'])
speaker.success_sound(sounder)
else:
speaker.fail_sound(sounder)
except Exception as e:
speaker.fail_sound(sounder)
print("EXCEPTION: %s" % e)
time.sleep(5)
def init():
app.make_context()
db.load(database_location)
import ConfigParser
import db
load = db.load()
insert = db.insert()
def loadconnections():
global servers
config = ConfigParser.RawConfigParser()
config.read("settings.cfg")
servers = {}
server_names = []
for s in config.sections():
#tom lista for settings
settings = []
#klipp server: fran namnet
name = s[7:]
server_names.append(s[7:])
#item ar en dictionary for de installningar som finns
item = dict(config.items(s))
item['name'] = name
#lagg till items i settings listan
settings.append(item)
#extr current chunknamn
namn = item['name']
def _build_df(self):
self.df = load(
f"SELECT * FROM signal WHERE scan_instance={self.scan} AND snq>0")
self.real_channels = self.df["channel"].values.tolist()
import db
db.silent(True)
if not db.exists("./version"):
class setup1(db.db):
setup = {
"major":db.number(),
"middle":db.number(),
"minor":db.number(),
}
name = "version"
table1 = setup1()
table1.new_record(major=0,middle=0,minor=0)
table1.save("version")
table1 = db.load("version")
version = table1.query().get()
print(version)
print("version {}.{}.{}".format(version["major"],version["middle"],version["minor"]))
print("update major [0]")
print("update middle [1]")
print("update minor [2]")
print("reset [3]")
while True:
i = int(input(">>>"))
if i in [0,1,2]:
if i == 0:
version["major"] += 1
elif i == 1:
version["middle"] += 1
parser = argparse.ArgumentParser(
description='Generate a graphviz dot graph for Factorio demands.')
parser.add_argument('demands',
type=str,
help='Expression, e.g. "2*Inserter + 1/2 * Black Science"')
parser.add_argument(
'--bus',
type=str,
default='',
help=
'Coma-separated list of "unlimited" stuff on your bus, e.g. "Iron Plate, Engine"'
)
args = parser.parse_args()
item_types = db.load()
def _parse_section(section):
try:
try:
num, name = section.split("*")
except:
num, name = section.strip().split(" ", 1)
num = _F(num)
name = name.strip()
except:
raise Exception("Expecting the format similar to: "
"\"2*Inserter + 1/2 * Black Science\"")
return num, _parse_item_type(name)
from pprint import pprint
import praw
import db
reddit = praw.Reddit(user_agent="Path of Exile unique item helper")
subreddit = reddit.get_subreddit("pathofexile")
posts = subreddit.get_top_from_day()
all_items = db.load()
for post in posts:
for comment in post.comments:
text = comment.body
for item_categories in all_items:
for items in item_categories:
for item in items:
if item["name"] in text:
print("-------------------")
pprint(text)
pprint(item, indent=4)
print("-------------------")
def load_solution_db_file(problem_id):
solution_db_file = 'problem_' + str(problem_id) + '_solution.db.txt'
return db.load(solution_db_file)
from db import load
from restaurant import *
food = load('food')
order = {
"items": [],
"total": {
"amount": 0,
"currency" : "MDL"
},
"client": {
"fullname": "Enter your name",
"address": {
"city": "Enter your City",
"street": "Enter your street",
"appartment": "Enter number of apartment"
},
"delivery": "Do you want delivery?(Y/N)"
}
}
# printItems(food, 'Today\'s Menu')
while True:
action = printActionsMenu([
'Show food',
'Order Food',
'Show Order',
'Check out',
'Print bill',
'Exit'
print('total words :', res[0])
print('discovered words :', res[1])
print('not practised words :', res[2])
print('fully practised words :', res[3])
print('fully tested words :', res[4])
input('\n\npress enter to continue...')
def main():
while True:
clear()
print(config.menu)
ans = input(config.menu_question).lower()
if ans == 'e':
db.dump()
exit()
elif ans == 'd':
discover()
elif ans == 'p':
practise()
elif ans == 't':
test()
elif ans == 's':
showstats()
if __name__ == '__main__':
db.load()
db.shuffle()
main()
def load():
return db.load(problem_db_file)
def load(self):
self.settings, self.teams, self.systems, \
self.checks, self.injects, self.remote = db.load()
#!/usr/bin/env python
import codecs
import sys
import db
import formatting
import settings
if __name__ == "__main__":
[book_dir, handbook_path] = sys.argv[1:]
# read db file
days = db.load(book_dir)
# write out tex
with open(handbook_path, 'w') as handbook_file:
write = handbook_file.write
write(formatting.book_begin)
for day in days:
day_short_name = settings.day_short_names[day.title]
session_locations = settings.day_session_locations[day.title]
session_chairs = settings.day_session_chairs[day.title]
# write day header
write(formatting.day_heading_format(title=day.title))
# collect schedule items for the day
schedule_items = []
for slot in day.slots:
# non-parallel sessions
if len(slot.sessions) == 1:
from flask import Flask
import routes_and_models, error_handlers, db
# Creating instance of the API
app = Flask("MagicAPI")
app.config['DEBUG'] = True
# Load error handlers
error_handlers.load(app)
db.load(app)
# Load routes for the app
routes_and_models.load(app)
if __name__ == "__main__":
app.run()
if __name__ == "__main__":
import options, sys, server, logging, db, os.path
logging.info("Starting %s.", server.server_name())
logging.debug("Command logging is %sabled.", "en" if options.args.log_commands else "dis")
from twisted.internet import reactor
if not os.path.isfile(options.args.dump_file):
logging.info("Creating empty database.")
with open(options.args.dump_file, "w") as f:
f.write("{}")
db.load()
server.port = server.initialise()
reactor.run()
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import cgitb,cgi
import db
cgitb.enable()
print("Content-Type: application/json;charset=utf-8")
print()
id = cgi.FieldStorage().getvalue('id')
if id is None:
print("{'error':'Empty id'}")
else:
ret=db.load(id)
print(ret["analysis"])
def init():
app.make_context()
db.load(database_location)
import sys
import db
import formatting
import settings
if __name__ == "__main__":
[book_dir, workshop_path] = sys.argv[1:]
# get workshop info
workshop_abbrev = os.path.basename(book_dir)
title = settings.workshop_titles[workshop_abbrev]
location = settings.workshop_locations[workshop_abbrev]
# read db file
days = db.load(book_dir)
# write out tex
with open(workshop_path, 'w') as workshop_file:
write = workshop_file.write
for day in days:
day_short_name = settings.day_short_names[day.title]
# collect abstracts
abstract_items = []
for slot in day.slots:
for session in slot.sessions:
for paper in session.papers:
if abstract_items:
abstract_items.append(
formatting.session_abstract_separator)
