def githook(webhook_payload): ref = webhook_payload['ref'].split('/')[-1] if ref != unpublished.name: if ref == published.name: published.pull() return added = [] modified = [] removed = [] for commit in webhook_payload['commits']: if commit['id'] == unpublished.branch.commit.hexsha: return added.extend(commit['added']) modified.extend(commit['modified']) removed.extend(commit['removed']) print(f'{len(added)} added, {len(modified)} modified, {len(removed)} removed') with _lock: if _pending_commit: finalize_commit() git.pull('-Xtheirs') if added or removed or '_project.json' in modified or '_publication.json' in modified: import app app.init() from search import search search.update_partial(added, modified)
def githook(webhook_payload, branch_name=unpublished.name): ref = webhook_payload['ref'].split('/')[-1] if ref != branch_name: return added = [] modified = [] removed = [] for commit in webhook_payload['commits']: if commit['id'] == unpublished.branch.commit.hexsha: return added.extend(commit['added']) modified.extend(commit['modified']) removed.extend(commit['removed']) print( f'{len(added)} added, {len(modified)} modified, {len(removed)} removed' ) with _lock: if _pending_commit: finalize_commit() git.pull('-Xtheirs') if added or removed: import app app.init() from search import search #search.files_removed([( filepath, get_deleted_file_data(filepath) ) for filepath in removed]) search.update_partial(added, modified)
def run(self): cov = coverage(branch=True, include=['app/*']) cov.start() app.init( MONGODB_SETTINGS={'DB': 'testing'}, TESTING=True, CSRF_ENABLED=False ) test_loader = unittest.defaultTestLoader test_runner = unittest.TextTestRunner() test_suite = test_loader.discover('./tests') try: test_runner.run(test_suite) except: pass cov.stop() cov.save() print("\n\nCoverage Report:\n") cov.report() print("HTML version: " + os.path.join("tmp/coverage/index.html")) cov.html_report(directory='tmp/coverage') cov.erase()
def run(self): cov = coverage(branch=True, include=['app/*']) cov.start() app.init(MONGODB_SETTINGS={'DB': 'testing'}, TESTING=True, CSRF_ENABLED=False) test_loader = unittest.defaultTestLoader test_runner = unittest.TextTestRunner() test_suite = test_loader.discover('./tests') try: test_runner.run(test_suite) except: pass cov.stop() cov.save() print("\n\nCoverage Report:\n") cov.report() print("HTML version: " + os.path.join("tmp/coverage/index.html")) cov.html_report(directory='tmp/coverage') cov.erase()
def select_device_and_run(event): myLabel = tk.Label(window, text="Device: " + variable.get()).pack() w.destroy() device_label.destroy() prediction_label.place(relx=.5, rely=.5, anchor="center") # set device device_info = sd.query_devices(get_host_id(variable.get()), 'input') device = get_host_id(variable.get()) sample_rate = device_info['default_samplerate'] channels = 1 init_pre_processing() init_activity_detection() init_feature_extraction(func_type="all", n_mfcc_arg=10, norm_file=normalization_values) init_classificator(knn_model=knn_model) init(sample_rate, buffer_size) stream = sd.InputStream(device=device, channels=channels, dtype='float32', latency='high', samplerate=sample_rate, callback=audio_callback, blocksize=buffer_size) window.protocol("WM_DELETE_WINDOW", on_closing) with stream: print("Recording***") window.mainloop()
def client(): db_fd, dbtmpfile = tempfile.mkstemp() app.app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///" + dbtmpfile config_fd, app.app.config['FOOKIE_CONFIG_FILE'] = tempfile.mkstemp() app.app.config['TESTING'] = True client = app.app.test_client() with open(app.app.config['FOOKIE_CONFIG_FILE'], 'w') as stream: stream.write(""" adminkeys: - FRANK sessiontimeout: 3600""") with app.app.app_context(): app.init() yield client os.close(db_fd) os.unlink(dbtmpfile) os.close(config_fd) os.unlink(app.app.config['FOOKIE_CONFIG_FILE'])
def run(self): app.init() app.app.run( use_debugger = True, use_reloader = True, host = '0.0.0.0' )
def setUp(self): app.init(MONGODB_SETTINGS={'DB': 'testing'}, TESTING=True, CSRF_ENABLED=False) self.app = app.app.test_client() generateMusic('1') generateMusic('2')
def test_init(): import app with mock.patch.object(app.app, "run", return_value=42): with mock.patch.object(app, "__name__", "__main__"): with mock.patch.object(app.app, "run") as mock_exit: app.init() assert mock_exit.call_args == mock.call(debug=True, host="0.0.0.0")
def main(argv): ''' Main entry point into the program. ''' # Get arguments and argument parser. (args, parser) = app.cli(argv) # Initialize logging and set verbosity level. logger = logging.get_logger(__name__) logger.debug(f'Program arguments: {argv}') # Check if any command arguments have been passed. if (len(argv) <= 1): # No arguments passed. logger.warning(f'No command arguments passed') #parser.print_help() #sys.exit(errno.EAGAIN) if args.list_configs: configs = settings.list_configs() print(configs) return os.EX_OK # Initialize our app. try: app.init(args) except Exception as e: logger.exception(e) logger.failure(f'App initialization failed: {e.errno}') parser.print_help() return os.EX_SOFTWARE # Load application configuration. try: config = app.load_config(args) except Exception as e: logger.exception(e) logger.failure(f'App configuration failed: {e.errno}') parser.print_help() return os.EX_CONFIG # Do something with config before running main app logic. # Run main app logic try: exit_code = app.process(args, config) except Exception as e: logger.exception(e) logger.failure(f'App processing failed: {e.errno}') parser.print_help() return os.EX_SOFTWARE # Handle anything else you need to, we're getting out of here. return exit_code
def __init__(self): "Старт!" # корневой путь self.basepath = os.path.dirname(os.path.abspath(__file__)) os.chdir(os.path.join(self.basepath, 'bin')) self.clearSessionLocks() self.initGettext() # импорт app.py должен идти после инициализации локализации import app app.init(self.basepath)
def setUp(self): app.init( MONGODB_SETTINGS={'DB': 'testing'}, TESTING=True, CSRF_ENABLED=False ) self.app = app.app.test_client() generateMusic('1') generateMusic('2')
def main() -> None: args = parse_args() try: if args.config: configs = load_config_file(args.config) else: configs = load_config_environ(args.debug) except Exception: print(strings.FAILED_TO_LOAD_CONFIG) return app.init(configs, debug=args.debug) app.run()
def setUp(self): app.config['TESTING'] = True init(app) init_db(app) self.cli = app.test_client() self.admin_token = encode_user_token(app.config['ADMIN_USERNAME']).decode("utf-8") normal_user = { "username": "******", "password": "******" } User.objects(username=normal_user["username"]).upsert_one(**normal_user).save() self.user_token = encode_user_token("normal").decode("utf-8")
def setUp(self): self.KB_URL = flaskapp.KB_URL self.AUDIO_URL = flaskapp.AUDIO_URL flaskapp.app.config['TESTING'] = True self.client = flaskapp.app.test_client() flaskapp.init() self.goal_input = self.get_symbolic_intput('goal/input_symbolic1.json') self.pass_input = self.get_symbolic_intput('pass/input_symbolic1.json') self.possession_input = self.get_symbolic_intput('possession/input_symbolic1.json') self.intercept_input = self.get_symbolic_intput('intercept/input_symbolic1.json') print()
def run(): pyglet.options['audio'] = AUDIO_DRIVERS pyglet.options['debug_gl'] = False parser = OptionParser(description="%s: %s" % (APP_NAME, PROJECT_DESC), epilog='Project website: %s' % PROJECT_URL, version='%s %s' % (APP_NAME, VERSION), ) parser.add_option("-f", "--fullscreen", dest="fullscreen", default=False, action="store_true", ) parser.add_option("-d", "--debug", dest="debug", default=False, action="store_true", ) options, args = parser.parse_args() if options.debug: logging.basicConfig(level=logging.DEBUG) logging.debug("Debug enabled") logging.debug("Options: %s" % options) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_LINE_SMOOTH); gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE) # depth testing #gl.glEnable(gl.GL_DEPTH_TEST) plib.director.director.init(width=WIDTH, height=HEIGHT, fullscreen=options.fullscreen, caption=APP_NAME, debug=options.debug) plib.director.director.on_cleanup = on_cleanup app.init() plib.director.director.run()
async def async_main() -> None: app = init() while True: msg = await app.work_endpoint.recv_multipart() padding = None work: Tuple[bytes, ...] try: # return_addr = msg[0] padding = msg[1] assert padding == b"" work = tuple(msg[2:]) except Exception as e: logging.exception("bad msg: %s - %s", msg, e) try: await handle(app, work) except Exception as e: logging.exception("handler died: %s", e)
def start_server(): WS_UNSECURE = os.environ.get('WS_UNSECURE') == "true" PORT = int(os.environ.get('CONTAINER_PORT')) info("Starting server ...") loop = asyncio.get_event_loop() # Set up SIGTERM handler for s in (signal.SIGINT, signal.SIGTERM): loop.add_signal_handler(s, lambda: loop.stop()) if WS_UNSECURE: # Start server with no SSL server_task = websockets.serve(main, HOST, PORT) else: # Load SSL certs try: ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) ssl_context.load_cert_chain(FULLCHAIN_PATH, keyfile=PRIVKEY_PATH) except PermissionError: fatal("Could not load {} or {}".format(FULLCHAIN_PATH, PRIVKEY_PATH)) # Start server with SSL server_task = websockets.serve(main, HOST, PORT, ssl=ssl_context) loop.run_until_complete(server_task) loop.run_until_complete(task.init()) loop.run_until_complete(app.init()) success("Server ready") # Wait until a SIGTERM is received or CTRL+C is pressed try: loop.run_forever() except KeyboardInterrupt: print() success("Server shutdown")
# coding:utf-8 from app import init if __name__ == '__main__': init()
def main(): app = KnightApp(KnightWindow) app.init() app.mainloop()
from flask import jsonify from app import app, init from model.rectangle import Rectangle rectangles = init() @app.route('/api/<x1>/<y1>/<x2>/<y2>/<label>') def add_rectagle(x1, y1, x2, y2, label): x1 = float(x1) y1 = float(y1) x2 = float(x2) y2 = float(y2) rect = Rectangle( (x1, y1), (x2, y2), {label: 1} ) if len(rectangles) > 0: closest = min(rectangles, key=rect.distance) dist = rect.distance(closest) else: dist = float('inf') if dist > 0.0005: # TODO: tune this value rectangles.append(rect) else: closest.labels[label] += 1 return jsonify()
import os import sys if os.environ.get('FLASK_ENV') == "production": import eventlet eventlet.monkey_patch() from eventlet import wsgi from app import app, init from db import init_db from util import get_logger logger = get_logger('chargepoint') app.logger = logger init(app) init_db(app) if __name__ == '__main__': app.logger.info("Starting server") if os.environ.get('FLASK_ENV') == "production": wsgi.server(eventlet.listen(('0.0.0.0', app.config['PORT'])), app, debug=False, log_output=False) else: app.run(port=app.config['PORT'])
def get_app(self): return init()
import mc import os import sys import re VERSION = "0.1 beta" CWD = os.getcwd().replace(";","") APPID = mc.GetApp().GetId() try: IDENTIFIER = "boxee_" + mc.GetDeviceId() + mc.GetInfoString('System.ProfileName').replace(' ', '') except: IDENTIFIER = "boxee_" + mc.GetInfoString('System.ProfileName').replace(' ', '') sys.path.append(os.path.join(CWD, 'libs')) import tracker GA = tracker.GA('UA-19866820-2') if ( __name__ == "__main__" ): mc.ActivateWindow(14000) GA.setPageView('home') import app main_obj = app.init()
# (because of the Reloader) if not server.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true": logging.getLogger("MX3.HWR").info("Starting MXCuBE3...") atexit.register(kill_processes) with open("/tmp/mxcube.pid", "w") as f: f.write(str(os.getpid()) + " ") from core import loginutils # Make the valid_login_only decorator available on server object server.restrict = loginutils.valid_login_only server.require_control = loginutils.require_control server.ws_restrict = loginutils.ws_valid_login_only mxcube.init(hwr, cmdline_options.hwr_directory, cmdline_options.allow_remote, cmdline_options.ra_timeout, cmdline_options.video_device, cmdline_options.log_file, cfg) # Install server-side UI state storage mxcube.init_state_storage() # Importing REST-routes from routes import (main, login, beamline, mockups, samplecentring, samplechanger, diffractometer, queue, lims, workflow, detector, ra, log) msg = "MXCuBE 3 initialized, it took %.1f seconds" % (time.time() - t0) logging.getLogger("MX3.HWR").info(msg)
import zmq import app import rpc app.init('/etc/scaledemo.conf') rpc_in_spec = app.config.get('edgemanager', 'rpc_in_spec') logger = app.logger zmq_context = zmq.Context() rpc_server = None def method_handler(method, args, data): if len(args) > 0: logger.info('call: %s(%s)' % (method, args)) else: logger.info('call: %s()' % method) if method == 'ping': return True else: raise rpc.CallError('method-not-found') def rpc_server_worker(c): global rpc_server rpc_server = rpc.RpcServer([rpc_in_spec], context=zmq_context) c.ready() rpc_server.run(method_handler, None) app.spawn(rpc_server_worker, wait=True) app.wait_for_quit()
daemonize = True if daemonize: print("Running as a daemon") import daemon import signal context = daemon.DaemonContext(working_directory=os.getcwd()) context.signal_map = { signal.SIGTERM: app_exit, } with context: import app app.init(daemonize) while 1: time.sleep(1) else: print("Enter q to quit...") import app app.init(daemonize) try: while 1: if raw_input() == "q": break except KeyboardInterrupt: pass app_exit(None, None)
def setup(self): app = init(store_root=root_dir, redis_url=REDIS_URL) self.testapp = webtest.TestApp(app, cookiejar=jar)
def test_translate(): app.init() lang, text = app.translate_text("wo bu yao") assert lang == 'zh' lang, text = app.translate_text("hello") assert text == ""
def main(): app = TerrainApp(TerrainWindow) app.init() app.mainloop()
# Requirements (since I don't have virtualenv or a better dependency system # set up yet) # - Flask -- flask.pocoo.org # $ sudo pip install flask # - psycopg2 -- initd.org/psycopg # $ sudo apt-get install libpq-dev python-dev # Has to be built # $ sudo pip install psycopg2 # - PyYAML -- (references but doesn't require libyaml) # $ sudo pip install PyYAML # - glob2 -- github.com/miracle2k/python-glob2 # Configure Flask import app app.init(__name__, static_folder='static', template_folder='templates' ) import index import tables if __name__ == '__main__': app.app.run(debug=True)
#!/usr/bin/env python import fapws._evwsgi as evwsgi from fapws import base import app evwsgi.start('0.0.0.0', '8080') evwsgi.set_base_module(base) evwsgi.wsgi_cb(('/', app.init())) evwsgi.set_debug(0) evwsgi.run()
#!/usr/bin/env python from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop import app # Initialize app and serve. http_server = HTTPServer(WSGIContainer(app.init())) http_server.bind(8080, '127.0.0.1') http_server.start(0) IOLoop.instance().start()
def main(): app = BasicApp(BasicWindow) app.init() app.mainloop()
def test_init(): app.init()
for admin in vote['admins']: Address.create_if_not_exists(session, admin) vote_obj = PendingVote(address_from=admin, address_to=address, perm_type=perm_type, start_block=start_block, end_block=end_block) session.add(vote_obj) signals.votes_changed.emit() with profile_session_scope() as profile_db: profile = Profile.get_active(profile_db) with data_session_scope() as data_db: is_admin, is_miner = Permission.get_permissions_for_address( data_db, profile.address) if is_admin != profile.is_admin: profile.is_admin = is_admin signals.is_admin_changed.emit(is_admin) if is_miner != profile.is_miner: profile.is_miner = is_miner signals.is_miner_changed.emit(is_miner) signals.permissions_changed.emit() if __name__ == '__main__': import app app.init()
#!/usr/bin/env python3 #-*- coding:utf8 -*- #Data:2017-02-03 #Author:jsxnh([email protected]) #version:0.1 import asyncio from app import init if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(init(loop)) loop.run_forever()
def setUpModule(): app.init() db.init(app.app)
default=False,help='output version and exit') (options,args)=op.parse_args() if options.version: print "rdf2rdb.py version",app.version sys.exit(0) if not args: op.print_help() sys.exit(1) if options.database: settings.dbname=options.database if not options.dry_run: app.init(options) try: for source in args: log('parsing %s',source) p=parser(source,output_triples=options.output_triples) for s,p,o in p.triplegenerator(): s=unicode(s) if len(s)>settings.max_uri_length: log('uri too long: %s',s) continue p=unicode(p) if len(p)>settings.max_uri_length: log('uri too long: %s',p) continue
['/admin/article/manage', app.controllers.article_manage], ['/admin/article/modify', app.controllers.article_modify], ['/admin/article/delete', app.controllers.article_delete], ['/admin/category/manage', app.controllers.category_manage], ['/admin/category/modify', app.controllers.category_modify], ['/admin/category/delete', app.controllers.category_delete], ['/admin/message/manage', app.controllers.message_manage], ['/admin/message/create', app.controllers.message_create], ['/admin/message/delete', app.controllers.message_delete], ['/admin/comment/manage', app.controllers.comment_manage], ['/admin/comment/create', app.controllers.comment_create], ['/admin/comment/delete', app.controllers.comment_delete], ['/admin/config', app.controllers.config], ['/admin/config/password', app.controllers.config_password], ['/admin/config/title', app.controllers.config_title], ['/admin/config/email', app.controllers.config_email], ['/admin/logout', app.controllers.logout], ] if __name__ == "__main__": app = init() create_database(app) init_database(app) for route in routes: app.add_url_rule(route[0], endpoint=route[0], view_func=route[1], methods=['GET', 'POST']) app.run(host="0.0.0.0", port=80, debug=True)
volume.init() volume.refresh() domain.init() domain.refresh() options.init() options.refresh() shutdown.init() support.init() back.init() app.init() app.refresh() mainmenu_items = [] mainmenu_items.append(mainmenu.ListItem(gui.res.icon_status, gui.res.string_status, (status,gui.res.string_status_description))) mainmenu_items.append(mainmenu.ListItem(gui.res.icon_volume, gui.res.string_volume,(volume,gui.res.string_volume_description))) mainmenu_items.append(mainmenu.ListItem(gui.res.icon_domain,gui.res.string_domain, (domain,gui.res.string_domain_description))) mainmenu_items.append(mainmenu.ListItem(gui.res.icon_app, gui.res.string_app, (app,gui.res.string_app_description))) mainmenu_items.append(mainmenu.ListItem(gui.res.icon_options,gui.res.string_options, (options,gui.res.string_options_description))) mainmenu_items.append(mainmenu.ListItem(gui.res.icon_support,gui.res.string_support, (support,gui.res.string_support_description))) mainmenu.window.addItems(mainmenu_items) items_height = sum(map(lambda x:x.getHeight(), mainmenu_items)) mainmenu.window.addItem(gui.list.Separator(332 - mainmenu.window.getMarginTop() - items_height))
import logging import sys import app IS_DEV = False if __name__ == '__main__': IS_DEV = True app.init(debug=IS_DEV) from app.functions.emotion import emotion if IS_DEV: from flask import Flask, request app = Flask(__name__) functions = [ 'emotion', ] # app.add_url_rule(f'/test_message', 'test_message', test_message, methods=['POST', 'GET'], defaults={'request': request}) for function in functions: app.add_url_rule(f'/{function}', function, locals()[function], methods=['POST', 'GET'], defaults={'request': request}) app.run(host='127.0.0.1', port=8088, debug=True)
def create_app(mode="bot") -> Quart: import log # noqa: F401 import app return app.init(mode)
from app import init from bottle import run # ============================================================================ application = init() if __name__ == "__main__": run(app=application, port=8088)
server.config['SECRET_KEY'] = "nosecretfornow" server.register_error_handler(Exception, exception_handler) _session = Session() _session.init_app(server) socketio = SocketIO(manage_session=False) socketio.init_app(server) # the following test prevents Flask from initializing twice # (because of the Reloader) if not server.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true": mxcube.init(hwr, cmdline_options.hwr_directory, cmdline_options.allow_remote, cmdline_options.ra_timeout, cmdline_options.video_device, cmdline_options.log_file) from core import loginutils # Make the valid_login_only decorator available on server object server.restrict = loginutils.valid_login_only # Install server-side UI state storage mxcube.init_state_storage() # Importing REST-routes from routes import (main, login, beamline, mockups, samplecentring, samplechanger, diffractometer, queue, lims, workflow, detector, ra)
def test_imgur(): app.init() file = test_pillow() app.upload_to_imgur(file)
#!/var/venv/bin/python3.5 import asyncio from app import init loop = asyncio.get_event_loop() srv, handler = loop.run_until_complete(init(loop)) try: loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(handler.finish_connections())