def setUpClass(cls): model.connect_string = 'sqlite:///:memory:' model.echo = True model.init() model.Task('task1', 'category1') model.Task('task2', 'category2') model.commit()
def init( config_file = None ): cfg = config.init( config_file ) lib = cfg.get_path( 'library' ) if( not os.path.isdir( lib ) ): os.makedirs( lib ) model.init( os.path.join( lib, HIGURASHI_DB_NAME ) )
def sql(): init() root = Tkinter.Tk() root.geometry('800x600') root.title('microRNA查询工具') root.option_add("*Font", "helvetica -12") main = Main(root) main.pack() root.mainloop()
def run(): parser = argparse.ArgumentParser() parser.add_argument("model_dir", help="directory where model files are stored") args = parser.parse_args() logger.debug("Init BERT models") model.init(args.model_dir) logger.debug("Run app") waitress.serve(app.run("0.0.0.0", port=1337))
def init(library_path=None): global _LIBRARY if (library_path is not None): _LIBRARY = library_path else: _LIBRARY = DEFAULT_LIBRARY if (not os.path.isdir(_LIBRARY)): os.makedirs(_LIBRARY) model.init(os.path.join(_LIBRARY, HIGURASHI_DB_NAME), _LIBRARY)
def main(): # DB stuff connect() init() globalized.init() # TCP stuff listener = listen() # REST stuff launch()
def init( library_path = None ): global _LIBRARY if( library_path is not None ): _LIBRARY = library_path else: _LIBRARY = DEFAULT_LIBRARY if( not os.path.isdir( _LIBRARY ) ): os.makedirs( _LIBRARY ) model.init( os.path.join( _LIBRARY, HIGURASHI_DB_NAME ), _LIBRARY )
def setUp(self): class Brython(dict): def __init__(self): dict.__init__({}) self.DOC, self.SVG, self.HTML, self.AJAX = [self]*4 self.doc = dict(base=self) self['base'] = self['book'] = self self.cookie = '_xsrf=123456; ' self.WIN, self.STORAGE, self.JSON, self.TIME = [self]*4 self.__getitem__ = self.DIV = self.div = self.IMG = self.nop self.div = self.img = self.deploy = self.employ = self.nop self.show_front_menu = self.screen_context = self.nop self.aler = self.prom = self.conf = self.nop self.offsetLeft = self.offsetTop = self.menuX = self.menuY = 1 self.Id = self.search = '' self.location = self.target = self self.aargs = self.items = self.evs = [] def __le__(self, other): """ shades brython append operator """ pass def activate(self, **kwargs): self.aargs = kwargs def bind(self, ev, hook): self.evs.append(hook) return self def nop(self, *args, **kwargs): return self def __call__(self, *args, **kwargs): return self class _Gui(dict): def employ(self, **kwargs): print('setUp employ') #self['adm1n'].update(kwargs) return 'adm1n', 1 self.control = model.init() self.br = Brython() self.br.dumps = json.dumps self.br.loads = json.loads self.app = Gui(self.br) self.app._locate = self.app._filter = MagicMock(name='locate') self.app.menuX = self.app.menuY = 1 self.builder = Builder(self.br, self.control) self.builder.build_all(self.app) self.gui = _Gui() self.gui['adm1n'] = {} Gui.REV = {} self.control.ALL_THINGS = model.Thing.ALL_THINGS = {} self.control.items = []
def show_1(part): if request.method == 'GET': logfile.write( str(time.time()) + ": EXPERIMENT GET, part: " + part + "\n") if (part in ["1", "2", "3", "4"]): # Set the title for the top of the screen title = part # Set the link location if part == "1": link_loc = "/experiment/2" elif part == "2": link_loc = "/survey/1" elif part == "3": link_loc = "/experiment/4" elif part == "4": link_loc = "/survey/2" problem_text = render_template('problem' + part + '.html') data = {"title": title, "link": link_loc, "problem": problem_text} return render_template('enterEquation.html', data=data) else: logfile.write( str(time.time()) + ": EXPERIMENT POST, part: " + part + "\n") if (part in ["1", "2", "3", "4"]): #DO THE EQUATION SOLVING STUFF # Set the equation startEquation = request.form['equation'] # Set the title for the top of the screen title = part # Set the link location if part == "1": link_loc = "/experiment/2" isActive = active_list[0] elif part == "2": link_loc = "/survey/1" isActive = active_list[0] elif part == "3": link_loc = "/experiment/4" isActive = active_list[1] elif part == "4": link_loc = "/survey/2" isActive = active_list[1] startState = model.init(startEquation, isActive) problem_text = render_template('problem' + part + '.html') data = {"title": title, "link": link_loc, "problem": problem_text} # return template return render_template('view2.html', state=startState, data=data)
def main(args): """ >>> import model, control, rest >>> rest.load_props() >>> model.init("advcruddb", "test", 2) >>> _ = model.clean() >>> body = "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS05NTc0MmEwYmJkOGE5MjU3DQpDb250ZW50LURpc3Bvc2l0aW9uOiBmb3JtLWRhdGE7IG5hbWU9InBob3RvIjsgZmlsZW5hbWU9ImhlbGxvLnR4dCINCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbg0KDQpoZWxsbwoNCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tOTU3NDJhMGJiZDhhOTI1Nw0KQ29udGVudC1EaXNwb3NpdGlvbjogZm9ybS1kYXRhOyBuYW1lPSJuYW1lIg0KDQpoZWxsbw0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS05NTc0MmEwYmJkOGE5MjU3DQpDb250ZW50LURpc3Bvc2l0aW9uOiBmb3JtLWRhdGE7IG5hbWU9ImVtYWlsIg0KDQpoQGwubw0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS05NTc0MmEwYmJkOGE5MjU3LS0NCg==" >>> ctype = "multipart/form-data; boundary=------------------------95742a0bbd8a9257" >>> args = { "__ow_body": body, "__ow_headers": { "content-type": ctype}, "__ow_method": "post" } >>> _ = control.main(args) >>> _id = model.find()["docs"][0]["_id"] >>> args = { "__ow_path": "/"+_id} >>> control.main(args) {'body': 'aGVsbG8K', 'headers': {'Content-Type': 'text/plain'}} """ model.init(args["db"], "contact", 2) return control.main(args)
def test_insert_table_from_open_now(self): model.init('Chicago') model.insert_table_from_scrap('Chicago') baseurl='https://api.yelp.com/v3/businesses/search' headers={'Authorization': 'Bearer %s' % secret.api_key} params={} params['location']='Chicago' params['open_now']=True results=model.make_request_using_cache(baseurl,headers,params) model.insert_table_from_api(results,'bars') conn = sqlite3.connect('final507.sqlite') cur = conn.cursor() statement='select * from restaurants_info where id=?' cur.execute(statement,[results['businesses'][0]['id']]) result=cur.fetchone() self.assertEqual(results['businesses'][0]['id'],result[0]) conn.commit() conn.close()
def test_plot_prepare_type(self): model.init('Chicago') model.insert_table_from_scrap('Chicago') baseurl='https://api.yelp.com/v3/businesses/search' headers={'Authorization': 'Bearer %s' % secret.api_key} params={} params['location']='Chicago' params['price']=2 results=model.make_request_using_cache(baseurl,headers,params) model.insert_table_from_api(results,'bars') conn = sqlite3.connect('final507.sqlite') cur = conn.cursor() statement='select r.lati,r.logi,r.name,r.id from restaurants_info as r join city_info as c on c.Id=r.city where r.price=? and c.name =? limit 20' cur.execute(statement,('$$', 'Chicago')) result=cur.fetchall() data,style=model.plot_prepare(result) self.assertIsInstance(data,list) self.assertIsInstance(style,dict)
def start(): import socket model.init() serv_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, proto=0) serv_sock.bind(('', 9090)) serv_sock.listen(10) while True: client_sock, address = serv_sock.accept() print('Connected by', address) while True: data = client_sock.recv(64000) if not data: break request = pickle.loads(data) client_sock.sendall(check_request(request)) client_sock.close()
def getCrimeType(): crimeDate = request.args.get("cDate") crimeLng = request.args.get("cLng") crimeLtd = request.args.get("cLtd") df = pd.DataFrame({ "crimeDate": [crimeDate], "crimeLng": [float(crimeLng)], "crimeLtd": [float(crimeLtd)] }) crimeType = model.init(df, loaded_model) return jsonify(crimeType=str(crimeType[0]))
def test_init(self): init('tmp/config.json') with self.subTest(i=0): self.assertEqual(Ocean.DEFAULT_SIZE, 100000) with self.subTest(i=1): self.assertEqual(Shark.FULLNESS, 100000) with self.subTest(i=2): self.assertEqual(Shark.REPRODUCTION, 100000) with self.subTest(i=3): self.assertEqual(Shark.LIFE, 100000) with self.subTest(i=4): self.assertEqual(Guppies.REPRODUCTION, 100000) with self.subTest(i=5): self.assertEqual(Guppies.LIFE, 100000)
def main(): app = QtWidgets.QApplication(sys.argv) # A new instance of QApplication online_bills, onsite_bills = init() # We set the form to be our ExampleApp (design) user_view = UserOP(online_bills, onsite_bills) user_view.show() # Show the form # We set the form to be our ExampleApp (design) op_view = CounterOP(online_bills, onsite_bills, user_view) op_view.show() # Show the form app.exec_() # and execute the app
def __init__(self, root): ''' Init Form ''' self.root = root self.createFrameTop() self.createFrameMiddle() self.createFrameBottom() self.matrix = model.init() self.root['bg'] = root_bg self.root.bind("<KeyPress> ", self.bind_key)
async def initial_startup(): """ Calls the init() method in the model and prepares the model to receive predictions. The init task may take a long time to complete, so the settings field ready_to_predict will be updated asynchronously when init() completes. :return: {"result": "starting"} """ # Run startup task async init_task = asyncio.create_task(init()) settings.ready_to_predict = True return {"result": "starting"}
def __init__(self, root): ''' Init Form ''' self.root = root self.createFrameTop() self.createFrameMiddle() self.createFrameBottom() self.matrix = model.init() matrix_stack.append(self.matrix) matrix_stack_forward.append(self.matrix) self.btn_show_matrix(self.matrix) self.root.bind("<KeyPress> ", self.bind_key)
def initialize(): global m_k, tobn, k, samples, w_T, w_k, w_sum, w_X, E,P, update_int, topo, k_max, learn_stages update_int = 2500 k_max = 20 k = 0 learn_stages = 5 topo = ['bppv', 'alc', 'mm', 'v_', 'rv', 'pv_', 'pv1', 'pv2', 'pv', 'v'] #topo = bn.topo_ordered(m) m_k = bnmodel.init(cpts)# create a model to modify for n in e: m[n].value = e[n] m_k[n].value = e[n] tobn = [m_k[node] for node in topo]
def main(self): self.opts, args = self.parse_args() self.setup_logging() self.log.debug('Initializing database.') model.init(self.opts.dburi) self.session = model.Session() try: try: cmd = args.pop(0) except IndexError: cmd = 'status' if cmd == 'start': self.cmd_start(args) elif cmd == 'stop': self.cmd_stop(args) elif cmd == 'list': self.cmd_list(args) elif cmd == 'status': self.cmd_status(args) elif cmd == 'report': self.cmd_report(args) elif cmd == 'cancel': self.cmd_cancel(args) elif cmd == 'drop': self.cmd_drop(args) elif cmd == 'log': self.cmd_log(args) elif cmd == 'help': self.cmd_help(args) else: self.cmd_start([cmd] + args) except TrackerError, detail: self.log.error(detail) sys.exit(1)
def main(): config = configparser.ConfigParser() config.read(CONFIG) try: config['DEFAULT']['model'] except KeyError: config['DEFAULT']['model'] = 'dummy' with open(CONFIG, 'w') as fil: config.write(fil) if config['DEFAULT']['model'] == 'sqlite': ctr = model.MatchSqliteDb elif config['DEFAULT']['model'] == 'mysql': ctr = model.MatchMysqlDb elif config['DEFAULT']['model'] == 'postgresql': ctr = model.MatchPostgresqlDb elif config['DEFAULT']['model'] == 'dummy': ctr = model.MatchList else: print('WARNING: Config is broken!') sys.exit(1) model.init(ctr) choose_menu()
def reset_game(self): ''' reset game ''' global play_flag self.matrix = model.init() model.g_score = 0 self.label_top_list[1]['text'] = model.g_score del matrix_stack[0:] matrix_stack.append([self.matrix, model.g_score]) self.btn_show_matrix(self.matrix) play_flag = True self.show_play_time()
def __init__(self, panel, stepSize, speed, eccentricity, tilt, precession): self.panel = panel # Creates the animation self.animation = Scene(title="SolarSIM", x=400, y=0, width=800, height=800, center=(0, 0, 0)).scene self.system = model.init(eccentricity, tilt, precession) # Set settings self.stepSize = stepSize self.speed = speed self.eccentricity = eccentricity self.tilt = tilt self.precession = precession
async def initial_startup(): """ Calls the init() method in the model and prepares the model to receive predictions. The init task may take a long time to complete, so the settings field ready_to_predict will be updated asynchronously when init() completes. :return: {"result": "starting"} """ # Run startup task async load_dotenv() # Register the model to the server in a separate thread to avoid meddling with # initializing the service which might be used directly by other client later on future = pool.submit(register_model_to_server, os.getenv('SERVER_PORT'), os.getenv('PORT'), os.getenv('NAME')) init_task = asyncio.create_task(init()) settings.ready_to_predict = True return {"result": "starting"}
def show_index(): if request.method == 'GET': logfile.write( str(time.time()) + ": INDEX GET: EXPERIMENT GONE WRONG!!!\n") # begin.html, empty mathquill entry return render_template('begin.html') else: logfile.write( str(time.time()) + ": INDEX POST START: EXPERIMENT GONE WRONG!!!\n") # render view.html with initial state baked in startEquation = request.form['equation'] startActive = request.form['active'] print("got equation: " + startEquation) print("got active: " + startActive) startState = model.init(startEquation, startActive) print("start is: " + str(startState)) logfile.write( str(time.time()) + ": START STATE IS " + str(startState) + "\n") return render_template('view.html', state=startState)
def main(): model.init() model.train(data_collection.train_data)
import asyncio from lib import wait_for_job, check_file_exists repo_path = os.path.dirname(sys.path[0]) sys.path.append(os.path.join(repo_path, "src/gui")) import model as M import view as V import controller as C os.makedirs(os.path.join(repo_path, "test/scratch/seeds")) shutil.copy(os.path.join(repo_path, "configuration.pysh"), os.path.join(repo_path, "test/scratch/seeds")) M.init(None, os.path.join(repo_path, "test/scratch/seeds/configuration.pysh")) V.init(None) C.init(None) os.makedirs(os.path.join(repo_path, "test/scratch/seeds/groundtruth-data/round1")) shutil.copy(os.path.join(repo_path, "data/PS_20130625111709_ch3.wav"), os.path.join(repo_path, "test/scratch/seeds/groundtruth-data/round1")) run(["hetero", "start", "1", "1", "1"]) shutil.copy(os.path.join(repo_path, "data/PS_20130625111709_ch3-annotated-person1.csv"), os.path.join(repo_path, "test/scratch/seeds/groundtruth-data/round1")) V.context_ms_string.value = "204.8" V.shiftby_ms_string.value = "0.0" V.optimizer.value = "adam"
BLACK = (0, 0, 0) WHITE = (255, 255, 255) RED = (255, 0, 0) GREEN = (0, 255, 0) BLUE = (0, 0, 255) YELLOW = (255, 255, 0) PIECE_COLOURS = (WHITE, RED, GREEN, BLUE, YELLOW) PIECE_WIDTH = 30 PIECE_HEIGHT = 30 PIECE_MARGIN = 2 pygame.init() model.init() windowSurface = pygame.display.set_mode(( model.get_width() * (PIECE_WIDTH + PIECE_MARGIN), model.get_height() * (PIECE_HEIGHT + PIECE_MARGIN) )) pygame.display.set_caption('Same Game') clock = pygame.time.Clock() while True: clock.tick(30) windowSurface.fill(BLACK) for y in range(model.get_height()): for x in range(model.get_width()): colour = model.get_block_colour(x, y)
form.populate_obj(user) db_session.add(user) db_session.commit() login.login_user(user) return redirect(url_for('index')) return render_template('form.html', form=form) @app.route('/logout/') def logout_view(): #print "on logout"+ request.cookies print request.session login.logout_user() return redirect(url_for('index')) if __name__ == '__main__': # Initialize flask-login init_login() db_session = init('sqlite:///test.sqlite') # Create admin admin = admin.Admin(app, 'Auth', index_view=MyAdminIndexView()) # Add view admin.add_view(MyModelView(User, db_session)) # Create DB #db.create_all() #recreate() # Start app app.session_interface = RedisSessionInterface() app.run(debug=True)
except: print schema print row raise setattr(inst, col_name, val) session.add(inst) session.commit() if __name__ == "__main__": import sys import os if len(sys.argv) < 3: print "Usage: %s zip db" % (sys.argv[0]) sys.exit(0) gtfs_zip = sys.argv[1] db_file = sys.argv[2] if os.path.isfile(db_file): os.remove(db_file) model.init(db_file) gtfs_db = gtfs.GtfsArchive(gtfs_zip) load_from_gtfs(gtfs_db)
from logging import Formatter, FileHandler from forms import * from flask_migrate import Migrate from datetime import datetime from model import Artist, Venue, Show, Genres, db, init # ----------------------------------------------------------------------------# # App Config. # ----------------------------------------------------------------------------# app = Flask(__name__) moment = Moment(app) app.config.from_object('config') with app.app_context(): db.init_app(app) init() migrate = Migrate(app, db) # ----------------------------------------------------------------------------# # Filters. # ----------------------------------------------------------------------------# def format_datetime(value, format='medium'): date = dateutil.parser.parse(value) if format == 'full': format = "EEEE MMMM, d, y 'at' h:mma" elif format == 'medium': format = "EE MM, dd, y h:mma" return babel.dates.format_datetime(date, format)
def setUp(self): model.connect_string = 'sqlite:///:memory:' model.echo = True model.init()
#!/usr/bin/python import model model.init("/home/nori/Desktop/work/Trellonium/appkey.txt", "/home/nori/Desktop/work/Trellonium/secret.txt") b = model.BoardProxy("52a113d948daf8a31e0043dd") print b.members() xs = b.lists() print xs print xs[0]["id"] app = model.theApp print app.token_url("bgnoritest") app.token = file("/home/nori/Desktop/work/Trellonium/token.txt").read().split() #c = model.CardProxy.create_card(idList=xs[0]["id"], name="by bot", due="null")
from flask import Flask, request, render_template, session, flash, redirect from flask.ext.admin import Admin from flask.ext.admin.contrib.sqla import ModelView from model import User, init, recreate app = Flask(__name__) app.config.update(dict( DATABASE='/tmp/flaskr.db', DEBUG=True, SECRET_KEY='development key', USERNAME='******', PASSWORD='******' )) session_db = init('sqlite:///prova.db') admin = Admin(app) recreate() # Add administrative views here admin.add_view(ModelView(User, session_db)) @app.route('/login', methods=['GET', 'POST']) def login(): error = None if request.method == 'POST': if request.form['username'] == 'USERNAME': error = 'Invalid username' elif request.form['password'] == 'PASSWORD': error = 'Invalid password' else: session['logged_in'] = True flash('You were logged in') return redirect('/admin')
def main(gui): print('Pyndorama 0.1.0') builder = Builder(gui, model.init()) app = Main(builder, Gui(gui)) app.build_all(builder)
#!/usr/bin/python2.7 import importance_sampler as ims import model as m import bntools import bayesnet import operator import itertools T = 5 json = m.get_json('bayesnets/alc_inheritance.json') #json = m.get_json('bayesnets/bvg_example.json') #json = m.get_json('bayesnets/medicalNetwork.json') #json = m.get_json('bayesnets/toy.json') model = m.init(json) evidence = {'v_':False, 'rv':True, 'pv_':True } X = [n for n in model if not n in evidence] bntools.plot_net(model) methods = ['VE', 'LW', 'GS', 'AIS'] runs = 5 R = bntools.foo(model, X, evidence, T, json, methods, runs) bntools.plot_results(R)
) args = parser.parse_args() hparams = args.__dict__ # unused args provided by service hparams.pop('job_dir', None) hparams.pop('job-dir', None) output_dir = hparams.pop('output_dir') # Append trial_id to path if we are doing hptuning # This code can be removed if you are not using hyperparameter tuning output_dir = os.path.join( output_dir, json.loads( os.environ.get('TF_CONFIG', '{}') ).get('task', {}).get('trial', '') ) # calculate train_steps if not provided if hparams['train_steps'] < 1: # 1,000 steps at batch_size of 100 hparams['train_steps'] = (1000 * 100) // hparams['train_batch_size'] print ("Training for {} steps".format(hparams['train_steps'])) model.init(hparams) # Run the training job model.train_and_evaluate(output_dir, hparams)
def main(): opts, args = parse_args() print 'Using database: %s' % (opts.dburi) session = model.init(opts.dburi, echo=opts.debug) for datafile in args: data = etree.parse(open(datafile)) node_report = data.getroot() report = session.query(model.Report).get( node_report.get('report_timestamp')) if report: continue report = model.Report(report_timestamp = node_report.get('report_timestamp')) node_envoy = node_report.find('envoy') envoy = session.query(model.Envoy).get(node_envoy.get('serial_num')) if not envoy: envoy = model.Envoy(ip_addr = node_envoy.get('ip_addr'), mac_addr = node_envoy.get('mac_addr'), timezone = node_envoy.get('timezone'), serial_num = node_envoy.get('serial_num')) session.add(envoy) envoy.sw_version = node_envoy.get('sw_version') for node_device in node_report.findall('device'): device = session.query(model.Device).get(node_device.get('eqid')) if not device: device = model.Device(eqid = node_device.get('eqid'), part_num=node_device.get('part_num'), device_type=node_device.get('device_type'), envoy=envoy) session.add(device) device.image_bits = node_device.get('image_bits') device.admin_state = node_device.get('admin_state') device.condition_flags = node_device.get('condition_flags') device.observed_flags = node_device.get('observed_flags') device.control_bits = node_device.get('control_bits') for node_interval in node_report.findall('interval'): interval = session.query(model.Interval).get( node_interval.get('id')) if interval: continue interval = model.Interval( report=report, id=node_interval.get('id'), stat_duration=node_interval.get('stat_duration'), interval_duration=node_interval.get('interval_duration'), eqid=node_interval.get('eqid'), end_date=node_interval.get('end_date')) stats = model.IntervalStats( interval=interval) for i,v in enumerate(node_interval.get('stats').split(',')): setattr(stats, 'val%d' % i, v) session.add(stats) session.add(interval) for node_event in node_report.findall('event'): event = session.query(model.Event).get( node_event.get('id')) if event: continue event = model.Event( id = node_event.get('id'), correlation_id = node_event.get('correlation_id'), event_state = node_event.get('event_state'), event_code = node_event.get('event_code'), eqid = node_event.get('eqid'), serial_num = node_event.get('serial_num'), event_date = node_event.get('event_date'), ) device = session.query(model.Device).get(event.serial_num) if device: device.events.append(event) report.events.append(event) session.add(event) envoy.reports.append(report) session.add(report) session.commit()
) parser.add_argument( '--job-dir', help='this model ignores this field, but it is required by gcloud', default='junk' ) args = parser.parse_args() arguments = args.__dict__ # unused args provided by service arguments.pop('job_dir', None) arguments.pop('job-dir', None) output_dir = arguments.pop('output_dir') model.init(arguments.pop('bucket'), arguments.pop('train_steps') ) # Append trial_id to path if we are doing hptuning # This code can be removed if you are not using hyperparameter tuning output_dir = os.path.join( output_dir, json.loads( os.environ.get('TF_CONFIG', '{}') ).get('task', {}).get('trail', '') ) # Run the training job learn_runner.run(model.experiment_fn, output_dir)
def init_db(settings): # TODO: Add logging # Create DB structure if needed print settings['sqlalchemy.url'] # print settings[sqlalchemy.url] model.init(settings['sqlalchemy.url'])
import logging from sys import argv bokehlog = logging.getLogger("songexplorer") bokehlog.setLevel(logging.INFO) #bokehlog.info(...) _, configuration_file = argv import model as M import view as V import controller as C doc = curdoc() M.init(doc, configuration_file) V.init(doc) C.init(doc) cluster_buttons = row(V.which_layer, V.which_species, V.which_word, V.which_nohyphen, V.which_kind, column(V.color_picker, width=75, align='end'), width=M.gui_width_pix - 75) navigate_buttons = row( column(Spacer(height=41, width=40), column(V.panleft, width=50), Spacer(height=41, width=40), column(V.allleft, width=50)), column(V.zoomin, V.reset, V.zoomout, V.allout, width=50), column(Spacer(height=41, width=40), column(V.panright, width=50),
def ping_stop( stop_ids ): schedules = get_schedules() time = datetime.datetime.time( datetime.datetime.now() ) time = time.second + time.minute * 60 + time.hour * 3600 time_begin = time time_end = time + 3600 session = model.Session() busses = session.query( model.StopTimes.stop_id, model.Trips.route_id, model.Trips.trip_headsign, model.StopTimes.departure_time ) \ .filter( model.Trips.service_id.in_( schedules ) ) \ .filter( model.StopTimes.stop_id.in_( stop_ids ) ) \ .filter( model.Trips.trip_id == model.StopTimes.trip_id ) \ .filter( model.StopTimes.departure_time > time_begin ) \ .filter( model.StopTimes.departure_time <= time_end ) \ .order_by( model.StopTimes.departure_time ) return map( lambda x: ( x.stop_id, x.route_id, x.trip_headsign, x.departure_time ), list( busses ) ) if( __name__ == '__main__' ): model.init( 'grt.db' ) for stop, route, name, time in ping_stop( [ '1966', '2678', '2779', '3589', '3631' ] ): print '%s: %02d:%02d - Route %s' % ( stop, time / 3600, (time / 60) % 60, name )
def main(): init() fit() predict(isOffline=ISOFFLINE)
if __name__ == "__main__": host = os.getenv("APP_HOST", "localhost") port = int(os.getenv("APP_PORT", "8080")) app = web.Application() app.router.add_route('POST', '/login', post_login) app.router.add_route('POST', '/carts', post_carts) app.router.add_route('PATCH', '/carts/{cartid}', patch_carts) app.router.add_route('GET', '/foods', get_foods) app.router.add_route('GET', '/orders', get_orders) app.router.add_route('POST', '/orders', post_orders) app.router.add_route('GET', '/admin/orders', get_admin_orders) loop = asyncio.get_event_loop() loop.run_until_complete(model.init()) handler = app.make_handler() f = loop.create_server(handler, host, port) srv = loop.run_until_complete(f) print('serving on', srv.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass finally: loop.run_until_complete(handler.finish_connections(1.0)) srv.close() loop.run_until_complete(model.close()) loop.run_until_complete(srv.wait_closed()) loop.run_until_complete(app.finish()) loop.close()
args = parser.parse_args() hparams = args.__dict__ # unused args provided by service hparams.pop('job_dir', None) hparams.pop('job-dir', None) output_dir = hparams.pop('output_dir') # Append trial_id to path if we are doing hptuning # This code can be removed if you are not using hyperparameter tuning output_dir = os.path.join( output_dir, json.loads(os.environ.get('TF_CONFIG', '{}')).get('task', {}).get('trial', '')) # calculate train_steps if not provided if hparams['train_steps'] < 1: # 1,000 steps at batch_size of 100 hparams['train_steps'] = (1000 * 100) // hparams['train_batch_size'] print("Training for {} steps".format(hparams['train_steps'])) model.init(hparams) # Run the training job try: learn_runner.run(generate_experiment_fn(output_dir, hparams), output_dir) except: traceback.print_exc()
def main(): args = get_parser().parse_args() model.init(args.output) create_statuses() record_results(not args.clean, *args.files)
def test_update_city_name(self): new_city_name='Chicago' model.init(new_city_name) self.assertEqual(model.city_name,new_city_name)
def admin(): model.init() ## add a guestbook entry return render_template("admin.html", entries=model.get_entries())
# add a guestbook entry return render_template("addentry.html") @app.route("/delete", methods=["POST"]) def delete_entry(): delete_id = request.form["theid"] model.delete_entry(delete_id) return redirect("/") @app.route("/edit", methods=["POST"]) def edit_entry(): edit_id = request.form["theid"] new_text = request.form["message"] model.edit_entry(edit_id, new_text) return redirect("/") @app.route("/postentry", methods=["POST"]) def postentry(): name = request.form["name"] message = request.form["message"] model.add_entry(name, message) return redirect("/") if __name__ == "__main__": model.init(app) app.run(debug=True)
from lib import wait_for_job, check_file_exists repo_path = os.path.dirname(sys.path[0]) sys.path.append(os.path.join(repo_path, "src/gui")) import model as M import view as V import controller as C os.makedirs(os.path.join(repo_path, "test/scratch/freeze-classify")) shutil.copy(os.path.join(repo_path, "configuration.pysh"), os.path.join(repo_path, "test/scratch/freeze-classify")) M.init( None, os.path.join(repo_path, "test/scratch/freeze-classify/configuration.pysh")) V.init(None) C.init(None) os.makedirs( os.path.join(repo_path, "test/scratch/freeze-classify/groundtruth-data/round1")) shutil.copy( os.path.join(repo_path, "data/PS_20130625111709_ch3.wav"), os.path.join(repo_path, "test/scratch/freeze-classify/groundtruth-data/round1")) run(["hetero", "start", "1", "1", "1"]) shutil.copy(
parser.add_argument( '--job-dir', help='this model ignores this field, but it is required by gcloud', default='junk' ) args = parser.parse_args() arguments = args.__dict__ # unused args provided by service arguments.pop('job_dir', None) arguments.pop('job-dir', None) output_dir = arguments.pop('output_dir') model.init(arguments.pop('bucket'), arguments.pop('num_epochs') ) # Append trial_id to path if we are doing hptuning # This code can be removed if you are not using hyperparameter tuning output_dir = os.path.join( output_dir, json.loads( os.environ.get('TF_CONFIG', '{}') ).get('task', {}).get('trail', '') ) # Run the training job learn_runner.run(model.experiment_fn, output_dir)
final_argument_whitespace = True has_content = False def run(self): content = ( '<input type="checkbox" ' 'onChange="this.setAttribute(' '\'checked\', this.checked?\'checked\':\'\');"/>') return [docutils.nodes.raw('', content, format='html')] directives.register_directive('checkbox', Checkbox) directives.register_directive('editable', Editable) directives.register_directive('script', Script) directives.register_directive('jquery', JQuery) directives.register_directive('button', Button) app.secret_key = 'MNOPQR' if __name__ == '__main__': # pragma: no cover arg_parser = argparse.ArgumentParser() # pylint: disable=C0103 arg_parser.add_argument( '-c', '--config', default='config_default.py', help='Choose your config file') parser_args = arg_parser.parse_args() # pylint: disable=C0103 CONFIG_FILE = getattr(parser_args, 'config') if CONFIG_FILE: app.config.from_pyfile(CONFIG_FILE) db_model.init(app) app.run(debug=True, threaded=True)
@app.route("/add") def addentry(): ## add a guestbook entry return render_template("addentry.html") @app.route("/postentry", methods=["POST"]) def postentry(): name = request.form["name"] message = request.form["message"] model.add_entry(name, message) return redirect("/admin") @app.route("/admin") def admin(): return render_template("admin.html", entries=model.get_entries()) @app.route("/delete", methods=["POST"]) def postdelete(): post_id = request.form['delete'] model.delete_entry(post_id) return redirect('/admin') if __name__ == "__main__": model.init() app.run(debug=True)
parser.add_argument( '--job-dir', help='this model ignores this field, but it is required by gcloud', default='junk' ) args = parser.parse_args() arguments = args.__dict__ # unused args provided by service arguments.pop('job_dir', None) arguments.pop('job-dir', None) output_dir = arguments.pop('output_dir') model.init(arguments.pop('bucket'), arguments.pop('train_steps') ) # Append trial_id to path if we are doing hptuning # This code can be removed if you are not using hyperparameter tuning output_dir = os.path.join( output_dir, json.loads( os.environ.get('TF_CONFIG', '{}') ).get('task', {}).get('trail', '') ) # Run the training job learn_runner.run(model.experiment_fn, output_dir)