def runner(cls): # Run with a fresh server server = app.create_server(port=0, new_loop=True) t = app.launch(cls, 'firefox-app') t.test_init() t.test_set_result() # Install failsafe. Use a closure so failsafe wont spoil a future test isrunning = True def stop(): if isrunning: app.stop() app.call_later(TIMEOUT1, stop) # Enter main loop until we get out t0 = time.time() app.start() print('ran %f seconds' % (time.time() - t0)) isrunning = False # Check result if True: # not (ON_TRAVIS and ON_PYPY): # has intermittent fails on pypy3 t.test_check() # Shut down t.session.close()
def inner(simulation): database = dataset.connect('sqlite:///parameter.db') abcEconomics.parameter_database = database['parameter'] Form = form(parameter_mask, names) # pylint: disable=C0103 if serve: flexx.config.hostname = hostname flexx.config.port = port app.serve( basiclayout(Form, simulation, title, header, truncate_rounds, texts=texts, pages=pages, histograms=histograms)) app.start() else: app.launch(basiclayout(Form, simulation, title, header, truncate_rounds, texts=texts, pages=pages, histograms=histograms), windowmode='maximized', runtime=runtime) app.run() return lambda _: None
def try_start(): try: app.stop() app.start() except RuntimeError: res.append('start-fail') else: res.append('start-ok')
def test_serving_apps_at_output_message(): """ Test for 'Serving apps at' ready signal. """ with capture_log('info') as log: server = app.create_server() app.stop() # triggers event to stop app.start() assert 'Serving apps at' in ''.join(log)
def main(): if len(sys.argv) > 1: app.export(BeetMe, "beetme.html", link=0) else: app.serve(BeetMe) tornado_app = app.current_server().app tornado_app.add_handlers(r".*", [ (r"/beet.*", BeetHandler), ]) app.start()
def main(): # Create fresh ioloop and make flexx use it loop = IOLoop() loop.make_current() app.create_server() # Create model and manipulate prop model = MyModel1() model.foo = 3 model.foo = 4 # Run mainloop for one iterartion app.call_later(0, app.stop) app.start()
def test_flexx_in_thread3(): """ Test starting and creating server when a server is currently running. """ res = [] def main(): # Create fresh ioloop and make flexx use it loop = IOLoop() loop.make_current() app.create_server() app.start() def try_start(): try: app.start() except RuntimeError: res.append('start-fail') def try_create(): try: main() except RuntimeError: res.append('create-fail') t = threading.Thread(target=main) t.start() # With that thread running ... while not app.current_server()._running: time.sleep(0.01) with raises(RuntimeError): app.start() with raises(RuntimeError): app.create_server() t1 = threading.Thread(target=try_start) t1.start() t1.join() t2 = threading.Thread(target=try_create) t2.start() t2.join() # Stop app.stop() # Start does not work, but we can stop it! t.join() # Otherwise it would never join # Note that we cannot start it right after calling stop, because it wont # stop *at once*. We need to join first. assert res == ['start-fail', 'create-fail']
def main(): # Create fresh ioloop and make flexx use it # event.loop.reset() loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) app.create_server() # Create component and manipulate prop comp = MyComponent1() comp.set_foo(3) comp.set_foo(4) # Run mainloop for one iterartion loop.call_later(0.2, app.stop) app.start()
def inner(simulation): if not IMPORTERROR: if pypy is not None: def simulation(parameters): print("CALLING PYPY") call([ pypy, sys.argv[0], json.dumps(parameters), abce.simulation_name ]) database = dataset.connect('sqlite:///parameter.db') abce.parameter_database = database['parameter'] Form = form(parameter_mask, names) # pylint: disable=C0103 if serve: flexx.config.hostname = hostname flexx.config.port = port app.serve( basiclayout(Form, simulation, title, header, truncate_rounds, texts=texts, pages=pages, histograms=histograms)) app.start() else: app.launch(basiclayout(Form, simulation, title, header, truncate_rounds, texts=texts, pages=pages, histograms=histograms), windowmode='maximized', runtime=runtime) app.run() else: print("RUN PYPY") abce.simulation_name = sys.argv[2] simulation(json.loads(sys.argv[1])) return lambda _: None
def runner(cls): # Run with a fresh server server = app.create_server(port=0, new_loop=True) t = app.launch(cls, 'firefox-app') t.test_init() t.test_set_result() # Install failsafe. Use a closure so failsafe wont spoil a future test isrunning = True def stop(): if isrunning: app.stop() app.call_later(TIMEOUT1, stop) # Enter main loop until we get out t0 = time.time() app.start() print('ran %f seconds' % (time.time()-t0)) isrunning = False # Check result if True: # not (ON_TRAVIS and ON_PYPY): # has intermittent fails on pypy3 t.test_check() # Shut down t.session.close()
def test_more_stopping(): """ Test calling stop multiple times. """ # This is why you want to create new IOLoop instances for each test # Create new ioloop and make Flexx use it loop = IOLoop() loop.make_current() server = app.create_server() app.stop() # triggers event to stop app.start() app.stop() # Extra stop - pending stop event # Which means the next stop does hardly block t0 = time.time() app.call_later(0.2, app.stop) app.start() assert time.time() - t0 < 0.1 loop = IOLoop() loop.make_current() server = app.create_server() # But stops dont stack app.stop() app.stop() app.stop() app.stop() # Flush all stops ... app.stop() app.start() # ... so that we now have an expected loop t0 = time.time() app.call_later(0.2, app.stop) app.start() assert time.time() - t0 >= 0.1
def test_more_stopping(): """ Test calling stop multiple times. """ # This is why you want to create new IOLoop instances for each test # Create new ioloop and make Flexx use it loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) server = app.create_server() app.stop() # triggers event to stop app.start() app.stop() # Extra stop - pending stop event # Which means the next stop does hardly block t0 = time.time() loop.call_later(0.2, app.stop) app.start() assert time.time() - t0 < 0.1 loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) server = app.create_server() # But stops dont stack app.stop() app.stop() app.stop() app.stop() # Flush all stops ... app.stop() app.start() # ... so that we now have an expected loop t0 = time.time() loop.call_later(0.2, app.stop) app.start() assert time.time() - t0 >= 0.1
def test_restarting(): """ Test stopping and starting the ioloop. """ res = [] def add_res(i): res.append(i) def try_start(): try: app.start() except RuntimeError: res.append('RTE') # Create new ioloop always loop = IOLoop() loop.make_current() # Make Flexx use it server = app.create_server() app.call_later(0, add_res, 1) app.call_later(0, add_res, 2) app.call_later( 0, app.stop) # actually, just calling stop() would work as well app.start() assert server._running == False app.call_later(0, try_start) # test that cannot start twice app.call_later(0, add_res, 3) app.call_later(0, add_res, 4) app.call_later(0, app.stop) app.start() assert server._running == False app.call_later(0, try_start) # test that cannot start twice app.call_later(0, add_res, 5) app.call_later(0, add_res, 6) app.call_later(0, app.stop) app.start() assert server._running == False assert res == [1, 2, 'RTE', 3, 4, 'RTE', 5, 6]
def test_restarting(): """ Test stopping and starting the ioloop. """ res = [] def add_res(i): res.append(i) def try_start(): try: app.start() except RuntimeError: res.append('RTE') # Create new ioloop always loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) # Make Flexx use it server = app.create_server() loop.call_soon(add_res, 1) loop.call_soon(add_res, 2) loop.call_soon( app.stop) # actually, just calling stop() would work as well app.start() assert server._running == False loop.call_soon(try_start) # test that cannot start twice loop.call_soon(add_res, 3) loop.call_soon(add_res, 4) loop.call_soon(app.stop) app.start() assert server._running == False loop.call_soon(try_start) # test that cannot start twice loop.call_soon(add_res, 5) loop.call_soon(add_res, 6) loop.call_soon(app.stop) app.start() assert server._running == False assert res == [1, 2, 'RTE', 3, 4, 'RTE', 5, 6]
def test_restarting(): """ Test stopping and starting the ioloop. """ res = [] def add_res(i): res.append(i) def try_start(): try: app.start() except RuntimeError: res.append('RTE') # Create new ioloop always loop = IOLoop() loop.make_current() # Make Flexx use it server = app.create_server() app.call_later(0, add_res, 1) app.call_later(0, add_res, 2) app.call_later(0, app.stop) # actually, just calling stop() would work as well app.start() assert server._running == False app.call_later(0, try_start) # test that cannot start twice app.call_later(0, add_res, 3) app.call_later(0, add_res, 4) app.call_later(0, app.stop) app.start() assert server._running == False app.call_later(0, try_start) # test that cannot start twice app.call_later(0, add_res, 5) app.call_later(0, add_res, 6) app.call_later(0, app.stop) app.start() assert server._running == False assert res == [1, 2, 'RTE', 3, 4, 'RTE', 5, 6]
def test_restarting(): """ Test stopping and starting the ioloop. """ res = [] def add_res(i): res.append(i) def try_start(): try: app.start() except RuntimeError: res.append('RTE') # Create new ioloop always loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) # Make Flexx use it server = app.create_server() loop.call_soon(add_res, 1) loop.call_soon(add_res, 2) loop.call_soon(app.stop) # actually, just calling stop() would work as well app.start() assert server._running == False loop.call_soon(try_start) # test that cannot start twice loop.call_soon(add_res, 3) loop.call_soon(add_res, 4) loop.call_soon(app.stop) app.start() assert server._running == False loop.call_soon(try_start) # test that cannot start twice loop.call_soon(add_res, 5) loop.call_soon(add_res, 6) loop.call_soon(app.stop) app.start() assert server._running == False assert res == [1, 2, 'RTE', 3, 4, 'RTE', 5, 6]
proxies = app.manager.get_connections(self.__class__.__name__) names = [p.app.name.text for p in proxies] del proxies text = '<br />%i persons in this chat:<br /><br />' % len(names) text += '<br />'.join([name or 'anonymous' for name in sorted(names)]) self.people.text = text app.call_later(3, self._update_participants) @event.connect('ok.mouse_down', 'message.submit') def _send_message(self, *events): text = self.message.text if text: name = self.name.text or 'anonymous' relay.new_message('<i>%s</i>: %s' % (name, text)) self.message.text = '' class JS: @event.connect('new_message') def _update_total_text(self, *events): self.messages.text += ''.join([ev.msg for ev in events]) # Create global relay relay = Relay() if __name__ == '__main__': app.serve(ChatRoom) # m = app.launch(ChatRoom) # for use during development app.start()
self.process = subprocess.Popen( ["python3", "main.py", "--graphical", "True"] + args, shell=False) self.log("Proc. ID: " + str(self.process.pid)) with open("process.dat", "w") as f: f.write(str(self.process.pid)) @react.connect("quit.mouse_down") def _handle_quit(self, down): if down: try: os.remove("process.dat") except FileNotFoundError: pass self.kill_process() sys.exit() @react.connect("stop.mouse_down") def _handle_stop(self, down): if down: try: os.remove("process.dat") except FileNotFoundError: pass self.kill_process() # app.serve(LightFX_Controller) main = app.launch(LightFX_Controller) # main() if __name__ == "__main__": app.start(port=8080)
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2018/1/3 15:59 # @Author : yc # @Site : # @File : 16_group.py # @Software: PyCharm from flexx import app, ui, event class Example(ui.GroupWidget): def init(self): self.title = 'A silly panel' with ui.VBox(): self.progress = ui.ProgressBar(value=0.001) self.but = ui.Button(text='click me') class JS: @event.connect('but.mouse_down') def _change_group_title(self, *events): self.progress.value += 0.05 app.init_interactive(Example) app.create_server(host="127.0.0.1", port=8009, new_loop=False, backend='tornado') app.start()
def main(): # Create fresh ioloop and make flexx use it loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) app.create_server() # calls event.loop.integrate() app.start()
def start_flexx(): app.create_server(loop=asyncio.new_event_loop()) app.start()
def main(): # Create fresh ioloop and make flexx use it loop = IOLoop() loop.make_current() app.create_server() app.start()
def multiprocessing_func(): import flexx app.create_server(port=0) # Explicitly ask for unused port app.call_later(0.1, app.stop) app.start()
def try_start(): try: app.start() except RuntimeError: res.append('RTE')
def main(): app.stop() app.start() assert server.loop is IOLoop.current() res.append(3)
def try_start(): try: app.start() except RuntimeError: res.append('start-fail')