class Sandbox:
def __init__(self):
window = OpenGLWindow(600, 300, "Sandbox")
self.game_manager = Application(60, window)
def start(self):
self.game_manager.run()
def train(mode):
global trainingCurrentStep
trainingCurrentStep = 0
if mode == settings.NEAT_IP_KEY:
trainMode('../config_files/config_neat_ip',
settings.NEAT_IP_EVOLVING_STEPS, eval_genomes_neat_ip)
elif mode == settings.NEAT_DYCICLE_KEY:
trainMode('../config_files/config_neat_dycicle',
settings.NEAT_DYCICLE_EVOLVING_STEPS,
eval_genomes_neat_dycicle)
elif mode == settings.NEAT_DIP_KEY:
node_names = {
-1: 'a1',
-2: 'a*1',
-3: 'a2',
-4: 'a*2',
-5: 'a0',
-6: 'a*0',
0: 'u'
}
trainMode('../config_files/config_neat_dip',
settings.NEAT_DIP_EVOLVING_STEPS, eval_genomes_neat_dip,
node_names)
elif mode == settings.NEAT_TIP_KEY:
trainMode('../config_files/config_neat_tip',
settings.NEAT_TIP_EVOLVING_STEPS, eval_genomes_neat_tip)
elif mode == settings.NEAT_WALKER_KEY:
trainMode('../config_files/config_neat_walker',
settings.NEAT_WALKER_EVOLVING_STEPS,
eval_genomes_neat_walker)
app = Application()
app.play()
def main():
parser = argparse.ArgumentParser(description='Run the program')
parser.add_argument("--trainMode", help="Mode of training")
args = parser.parse_args()
settings.TRAIN_CALLBACK = train
if args.trainMode:
train(args.trainMode)
else:
app = Application()
app.play()
def __init__(self):
Application.__init__(self)
self.redir_port = Settings["main_app"]["redir_port"]
self.redir_app = tornado.web.Application([(r"/(.*)", RedirHandler)])
self.main_app = tornado.web.Application(
get_url_specs(),
# Server settings
static_path=os.path.join(os.path.dirname(__file__), "static"),
template_path=os.path.join(os.path.dirname(__file__), "templates"),
gzip=True,
login_url="/login",
cookie_secret=Settings["cookie_secret"],
ui_modules=ui_modules,
autoescape=None,
)
def __init__(self):
Application.__init__(self)
self.redir_port = Settings['main_app']['redir_port']
self.redir_app = tornado.web.Application([
(r'/(.*)', RedirHandler),
], )
self.main_app = tornado.web.Application(
get_url_specs(),
# Server settings
static_path=os.path.join(os.path.dirname(__file__), "static"),
template_path=os.path.join(os.path.dirname(__file__), "templates"),
gzip=True,
login_url="/login",
cookie_secret=Settings['cookie_secret'],
ui_modules=ui_modules,
autoescape=None,
)
from http.server import HTTPServer
from adapters.http_handler import ServerRequestHandler
from core.adapters import InMemoryPlaylistRepository, InMemoryPlaylistVideoRepository, InMemoryVideoRepository
from core.application import Application
if __name__ == '__main__':
server = HTTPServer(('0.0.0.0', 8000), ServerRequestHandler)
server.app = Application(InMemoryPlaylistRepository({}),
InMemoryPlaylistVideoRepository({}),
InMemoryVideoRepository({}))
server.serve_forever()
def eval_genomes_neat_ip(genomes, config):
idx, genomes = zip(*genomes)
app = Application()
global trainingCurrentStep
trainingCurrentStep += 1
app.trainNeatIP(genomes, config, trainingCurrentStep)
import sys
#sys.path.append('Q:/_sandbox_python/_platform/websockets-7.0/src')
#sys.path.append('Q:/_sandbox_python/_platform/paho-mqtt-1.4.0/src')
sys.path.append(
'.') # Permet les includes depuis le repertoire courant, pas terrible
from core.application import Application
from modules.property.PropertyModule import PropertyModule
from modules.admin.AdminModule import AdminModule
from modules.loto.LotoModule import LotoModule
#from modules.homie.HomieModule import HomieModule
if __name__ == "__main__":
application = Application('data/application.db')
application.addModule(AdminModule())
application.addModule(PropertyModule())
application.addModule(LotoModule())
application.run('localhost', 6789)
from core.application import Application
if __name__ == "__main__":
app = Application("client", {
"device": {
"class": "core.devices.tun.TUNDevice"
},
"link": {
"class": "core.links.tcp.TCPLink",
"port": 20121,
"host": "184.82.229.13",
},
"addons": [
{
"class": "core.addons.nameserver_override.NameserversEditor",
"nameservers": [
"8.8.4.4",
"208.67.222.222",
]
}
],
"set_default_gateway": True
})
app.run()
# based on unknown environment name
settings = build.settings(yaml)
# merge with session settings, session should be registered
# at tornado global settings, so it can be parsed by session mixin
# component.
settings.update(session = session.settings())
logger.debug('Settings: %s', settings)
logger.info('Running IOLoop...')
logger.info('Listening port: {}'.format(options.port))
logger.info('Listening to address: {}'.format(options.addr))
# Initialize Typhoon engine
# register root_path and motor as object property
typhoon = Typhoon(apps.get_routes(), **settings)
setattr(typhoon, 'root_path', root_path)
setattr(typhoon, 'motor', mongo.settings())
typhoon.listen(options.port, options.addr)
IOLoop.current().start()
except DotenvNotAvailableError, exc:
"""
Should be happened when core builder cannot load default dotenv file
"""
print exc.message
sys.exit()
except UnknownEnvError, exc:
"""
def __init__(self):
window = OpenGLWindow(600, 300, "Sandbox")
self.game_manager = Application(60, window)
# based on unknown environment name
settings = build.settings(yaml)
# merge with session settings, session should be registered
# at tornado global settings, so it can be parsed by session mixin
# component.
settings.update(session=session.settings())
logger.debug('Settings: %s', settings)
logger.info('Running IOLoop...')
logger.info('Listening port: {}'.format(options.port))
logger.info('Listening to address: {}'.format(options.addr))
# Initialize Typhoon engine
# register root_path and motor as object property
typhoon = Typhoon(apps.get_routes(), **settings)
setattr(typhoon, 'root_path', root_path)
setattr(typhoon, 'motor', mongo.settings())
typhoon.listen(options.port, options.addr)
IOLoop.current().start()
except DotenvNotAvailableError, exc:
"""
Should be happened when core builder cannot load default dotenv file
"""
print exc.message
sys.exit()
except UnknownEnvError, exc:
"""
from adapters.sql_video import SqlVideoRepository
from core.application import Application
class ForkingHTTPServer(ForkingMixIn, HTTPServer):
pass
if __name__ == '__main__':
import mysql.connector
config = {
'user': '******',
'password': '******',
'host': 'db',
'port': '3306',
'database': 'playlist'
}
def connect():
return mysql.connector.connect(**config)
print('Starting...')
connection = LazyConnection(connect)
server = ForkingHTTPServer(('0.0.0.0', 8000), ServerRequestHandler)
playlist_repository = SqlPlaylistRepository(connection)
playlist_video_repository = SqlPlaylistVideoRepository(connection)
video_repository = SqlVideoRepository(connection)
server.app = Application(playlist_repository, playlist_video_repository,
video_repository)
server.serve_forever()
def app_instance(custom_args):
"""Single application instance to be reused by all fixtures."""
runtime_args = defaultargs.copy()
runtime_args.update(custom_args)
return Application(**runtime_args)
import core.instrument
if config.get('debug') == True:
logger.setLevel(logging.DEBUG)
signal.signal(signal.SIGUSR1, core.instrument.dumpOnSignal)
else:
logger.setLevel(config.get('logLevel', logging.INFO))
if config.has_key('profile') and config['profile'].get('enabled') == True:
core.instrument.enableProfiler(signal.SIGPROF, config['profile'])
if config.has_key('pool'):
gevent.pool.Pool(config['pool'])
# [ Prepare the application ]
Application.setup(config)
# [ Define the dispatcher ]
def Dispatcher(env, start_response):
request = Request(env, start_response)
Application.run(request)
return request.getResponseBody()
# [Create Servers] #
servers = []
serverLog = 'default'
if not config.get('logRequests', True):
serverLog = None
def Dispatcher(env, start_response):
request = Request(env, start_response)
Application.run(request)
return request.getResponseBody()
import sys
from pyvirtualdisplay import Display
from core.application import Application
from core.reporter import Reporter
if __name__ == '__main__' and len(sys.argv) > 1:
settings = {}
if sys.argv[1] == 'ufbm':
from tasks.ufbm import collect_settings
from tasks.ufbm import unban_facebook_blocked_members
collect_settings(settings)
if not int(settings['application.visible']):
display = Display(backend='xvfb')
display.start()
app = Application(settings)
reporter = Reporter('ufbm', settings)
reporter.attach(app)
unban_facebook_blocked_members(app)
exit(app.start())
exit(-1)
import core.instrument
if config.get('debug')==True:
logger.setLevel(logging.DEBUG)
signal.signal(signal.SIGUSR1, core.instrument.dumpOnSignal)
else:
logger.setLevel(config.get('logLevel', logging.INFO))
if config.has_key('profile') and config['profile'].get('enabled')==True:
core.instrument.enableProfiler(signal.SIGPROF, config['profile'])
if config.has_key('pool'):
gevent.pool.Pool(config['pool'])
# [ Prepare the application ]
Application.setup(config)
# [ Define the dispatcher ]
def Dispatcher(env, start_response):
request = Request(env, start_response)
Application.run(request)
return request.getResponseBody()
# [Create Servers] #
servers = []
serverLog = 'default'
if not config.get('logRequests', True):
serverLog = None
for ip, ports in Application.vhosts.items():
for port, vhosts in ports.items():
def Dispatcher(env, start_response):
request = Request(env, start_response)
Application.run(request)
return request.getResponseBody()
def signal_handler(signum, frame):
if app:
app.exit(-1)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
if __name__ == '__main__' and len(sys.argv) > 1:
if sys.argv[1] == 'ufbm':
from tasks.ufbm import collect_settings
from tasks.ufbm import unban_facebook_blocked_members
collect_settings(settings)
#if not int(settings['application.visible']):
# from pyvirtualdisplay import Display
# display = Display(backend='xvfb')
# display.start()
app = Application('ufbm', settings)
reporter = Reporter('ufbm', settings)
reporter.attach(app)
unban_facebook_blocked_members(app)
exit(app.start())
exit(-1)
import asyncio
from logging import basicConfig, DEBUG, INFO # pylint:disable=unused-import
import os
from signal import SIGINT, SIGTERM
from core.application import Application
basicConfig(level=DEBUG)
loop = asyncio.get_event_loop()
try:
base_dir = os.path.dirname(os.path.abspath(__file__))
app = Application(loop, base_dir)
try:
loop.add_signal_handler(SIGINT, app.shutdown)
loop.add_signal_handler(SIGTERM, app.shutdown)
loop.run_until_complete(app.startup())
finally:
loop.run_until_complete(app.close())
# wait all tasks
loop.run_until_complete(asyncio.gather(*asyncio.Task.all_tasks()))
finally:
loop.close()