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 _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"])
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)