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())
from app import init
from bottle import run
# ============================================================================
application = init()
if __name__ == "__main__":
run(app=application, port=8088)
def setup(self):
app = init(store_root=root_dir, redis_url=REDIS_URL)
self.testapp = webtest.TestApp(app, cookiejar=jar)
