def setup(self): conf = AppConfig(minimal=True) conf.use_dotted_templatenames = True conf.renderers.append('mako') conf.package = FakePackage() self.conf = conf self.app = conf.make_wsgi_app()
def test_render_default(): conf = AppConfig(minimal=True) conf.default_renderer = 'json' app = conf.make_wsgi_app() res = tg.render_template({'value': 'value'}) assert 'value": "value' in res
def test_config_hooks_through_app_config(self): class RootController(TGController): @expose() def test(self): return 'HI!' visited_hooks = [] def before_config_hook(app): visited_hooks.append('before_config') return app def after_config_hook(app): visited_hooks.append('after_config') return app def configure_new_app_hook(app): assert isinstance(app, TGApp) visited_hooks.append('configure_new_app') conf = AppConfig(minimal=True, root_controller=RootController()) conf.register_hook('before_config', before_config_hook) conf.register_hook('after_config', after_config_hook) conf.register_hook('configure_new_app', configure_new_app_hook) app = conf.make_wsgi_app() app = TestApp(app) assert 'HI!' in app.get('/test') assert 'before_config' in visited_hooks assert 'after_config' in visited_hooks assert 'configure_new_app' in visited_hooks
def make_app(controller_klass=None, environ=None, config_options=None, with_errors=False, make_app=True): """Creates a `TestApp` instance.""" if controller_klass is None: controller_klass = TGController conf = AppConfig(root_controller=ControllerWrap(controller_klass), **default_config) # Just let exceptions crash. conf['trace_errors.enable'] = False if with_errors: conf['errorpage.enabled'] = True conf['errorpage.status_codes'] = [403, 404] else: conf['errorpage.enabled'] = False conf['session.enabled'] = True conf['session.data_dir'] = session_dir conf['cache.enabled'] = True conf['cache.cache_dir'] = cache_dir if config_options is not None: for k, v in config_options.items(): conf[k] = v if make_app: return TestApp(conf.make_wsgi_app()) else: return conf
def test_disconnect_hooks_multiple_listener(self): hook1_has_been_called = [] def hook1_listener(): hook1_has_been_called.append(True) hook2_has_been_called = [] def hook2_listener(): hook2_has_been_called.append(True) class RootController(TGController): @expose() def test(self): tg.hooks.notify('custom_hook', controller=RootController.test) return 'HI!' conf = AppConfig(minimal=True, root_controller=RootController()) tg.hooks.register('custom_hook', hook1_listener) tg.hooks.register('custom_hook', hook2_listener) conf.package = PackageWithModel() app = conf.make_wsgi_app() app = TestApp(app) app.get('/test') app.get('/test') tg.hooks.disconnect('custom_hook', hook2_listener) app.get('/test') # Disconnecting an unregistered hook should do nothing. tg.hooks.disconnect('unregistered', hook1_listener) assert len(hook1_has_been_called) == 3, hook1_has_been_called assert len(hook2_has_been_called) == 2, hook2_has_been_called
def test_startup_hook_with_exception(self): def func(): raise Exception tg.hooks.register('startup', func) conf = AppConfig(minimal=True) app = conf.make_wsgi_app()
def setup(self): conf = AppConfig(minimal=True) conf.use_dotted_templatenames = True conf.renderers.append('kajiki') conf.package = FakePackage() self.conf = conf self.app = TestApp(conf.make_wsgi_app()) self.render = tg.config['render_functions']['kajiki']
def test_startup_hook(self): executed = [] def func(): executed.append(True) tg.hooks.register('startup', func) conf = AppConfig(minimal=True) app = conf.make_wsgi_app() assert True in executed, executed
def setup(self): class RootController(TGController): @expose() def test(self): return str(bool(EqualsTwo())) conf = AppConfig(minimal=True, root_controller=RootController()) app = conf.make_wsgi_app() self.app = TestApp(app)
def setup(self): conf = AppConfig(minimal=True, root_controller=i18nRootController()) conf['paths']['root'] = 'tests' conf['i18n.enabled'] = True conf['session.enabled'] = True conf['i18n.lang'] = 'kr' conf['beaker.session.key'] = 'tg_test_session' conf['beaker.session.secret'] = 'this-is-some-secret' conf.renderers = ['json'] conf.default_renderer = 'json' conf.package = _FakePackage() app = conf.make_wsgi_app() self.app = TestApp(app)
def run(): global userconfig global httpd config = AppConfig(minimal=True, root_controller=RootController()) config['helpers'] = webhelpers2 config.renderers = ['kajiki'] config.serve_static = True config.paths['static_files'] = 'web/public' application = config.make_wsgi_app() print("Serving on port " + userconfig['Web']['porttoserve'] + "...") httpd = make_server('', int(userconfig['Web']['porttoserve']), application, 3) httpd.serve_forever()
def test_jinja_lookup_nonexisting_template(): conf = AppConfig(minimal=True) conf.use_dotted_templatenames = True conf.renderers.append('jinja') conf.package = FakePackage() app = conf.make_wsgi_app() from jinja2 import TemplateNotFound try: render_jinja = tg.config['render_functions']['jinja'] render_jinja('tg.this_template_does_not_exists', {'app_globals': tg.config['tg.app_globals']}) assert False except TemplateNotFound: pass
def test_jinja_lookup_nonexisting_template(): conf = AppConfig(minimal=True) conf.use_dotted_templatenames = True conf.renderers.append('jinja') conf.package = FakePackage() app = conf.make_wsgi_app() from jinja2 import TemplateNotFound try: render_jinja = tg.config['render_functions']['jinja'] render_jinja('tg.this_template_does_not_exists', {'app_globals':tg.config['tg.app_globals']}) assert False except TemplateNotFound: pass
def run_api(): global userconfig try: port = userconfig['Web']['apiport'] except KeyError: port = '9380' global httpd config = AppConfig(minimal=True, root_controller=APIRootController()) config['helpers'] = webhelpers2 config.renderers = ['kajiki'] config.serve_static = False application = config.make_wsgi_app() print("Serving APIs on port " + port + "...") httpd = make_server('', int(port), application, 3) httpd.serve_forever()
def run(): global userconfig try: port = userconfig['Web']['porttoserve'] except AttributeError: port = '9375' global httpd config = AppConfig(minimal=True, root_controller=RootController()) config['helpers'] = webhelpers2 config.renderers = ['kajiki'] config.serve_static = True config.paths['static_files'] = 'web/public' application = config.make_wsgi_app() print("Serving on port " + port + "...") httpd = make_server('', int(port), application, 3) httpd.serve_forever()
def testWebServer(): print("Hosting server") config = AppConfig(minimal=True, root_controller=RootController()) application = config.make_wsgi_app() httpd = make_server('', 62433, application) thr = threading.Thread(target=httpd.serve_forever) thr.start() print("Running test") page = urllib.request.urlopen('http://127.0.0.1:62433/') if page.read().decode() != "Hello World": raise RuntimeError("Server did not correctly host 'Hello World' page.") httpd.shutdown()
class WebInterface(Interface): __logger=logging.getLogger(__name__) config=None httpd=None application=None keep_running=True player=None controller=None def __init__(self, templatePath, staticPath, port, controller): self.__logger.debug("create WebInterface Instance") self.__logger.debug("setup TurboGears2") self.controller = controller self.config = AppConfig(minimal=True, root_controller=self.controller) #jinja stuff self.config.renderers.append('jinja') self.config.default_renderer = 'jinja' self.config.use_dotted_templatenames = False self.config.paths['templates'] = [templatePath] #statics self.config.serve_static = True self.config.paths['static_files'] = staticPath #make wsgi_app self.application = self.config.make_wsgi_app() #make wsgi_server self.httpd = make_server('', port, self.application, ThreadingWSGIServer) self.httpd.timeout = 5 def run(self): self.__logger.debug("run") while(self.keep_running): self.__logger.info("listening for Requests") try: self.httpd.serve_forever() except KeyboardInterrupt: self.shutdown() def shutdown(self): self.__logger.info("init shutdown") service.stop() self.keep_running=False
def testWebServer(): print("Hosting server") config = AppConfig(minimal=True, root_controller=RootController()) application = config.make_wsgi_app() httpd = make_server('', 62433, application) thr = threading.Thread(target=httpd.serve_forever) thr.start() print("Running test") page = request.urlopen('http://127.0.0.1:62433/') if page.read().decode() != "Hello World": raise RuntimeError("Server did not correctly host 'Hello World' page.") httpd.shutdown()
def setUp(self): self.root_controller = self.controller_factory() conf = AppConfig(minimal=True, root_controller=self.root_controller) conf.package = FakePackage() conf.model = conf.package.model conf.use_dotted_templatenames = True conf.renderers = ['json', 'jinja', 'mako'] conf.default_renderer = 'jinja' conf.use_sqlalchemy = True conf.paths = {'controllers': 'tests', 'templates': ['tests']} conf.disable_request_extensions = False conf.prefer_toscawidgets2 = True conf.use_transaction_manager = True conf['sqlalchemy.url'] = 'sqlite:///:memory:' self.app = TestApp(conf.make_wsgi_app()) metadata.create_all()
def start_server(): """ start webserver """ catalog_engine = create_engine(SQLITE_DATA_TARGET) login_engine = create_engine(LOGIN_DATA_TARGET) config = AppConfig(minimal=True, root_controller=RootController(catalog_engine, login_engine)) config.sa_auth.charset = 'utf-8' config.renderers = ['kajiki'] config.default_renderer = 'kajiki' config.serve_static = True config.paths['static_files'] = 'public' config.paths['controllers'] = 'controllers' application = config.make_wsgi_app() print "Serving on port 8080..." httpd = make_server('', 8080, application) httpd.serve_forever()
def setUp(self): self.root_controller = self.controller_factory() conf = AppConfig(minimal=True, root_controller=self.root_controller) conf.package = FakePackage() conf.model = conf.package.model conf.use_dotted_templatenames = True conf.renderers = ['json', 'jinja', 'mako'] conf.default_renderer = 'jinja' conf.use_sqlalchemy = True conf.paths = {'controllers':'tests', 'templates':['tests']} conf.disable_request_extensions = False conf.prefer_toscawidgets2 = True conf.use_transaction_manager = True conf['sqlalchemy.url'] = 'sqlite:///:memory:' self.app = TestApp(conf.make_wsgi_app()) metadata.create_all()
def test_controller_hooks_with_value(self): # Reset milestone so that registered hooks milestones._reset_all() class RootController(TGController): @expose() def test(self): return tg.hooks.notify_with_value('test_hook', 'BO', controller=RootController.test) def value_hook(value): return value*2 tg.hooks.register('test_hook', value_hook, controller=RootController.test) conf = AppConfig(minimal=True, root_controller=RootController()) app = conf.make_wsgi_app() app = TestApp(app) resp = app.get('/test') assert 'BOBO' in resp, resp
def test_disconnect_hooks(self): hook1_has_been_called = [] def hook1_listener(): hook1_has_been_called.append(True) class RootController(TGController): @expose() def test(self): tg.hooks.notify('custom_hook') return 'HI!' conf = AppConfig(minimal=True, root_controller=RootController()) tg.hooks.register('custom_hook', hook1_listener) conf.package = PackageWithModel() app = conf.make_wsgi_app() app = TestApp(app) app.get('/test') app.get('/test') tg.hooks.disconnect('custom_hook', hook1_listener) app.get('/test') assert len(hook1_has_been_called) == 2, hook1_has_been_called
for row in entry: total_power = 0 if row['POTENZA_da_116_a_350_KW']: total_power += int(row['POTENZA_da_116_a_350_KW']) * ((116+350)/2.0) if row['POTENZA_da_35_a_116_KW']: total_power += int(row['POTENZA_da_35_a_116_KW']) * ((35+116)/2.0) if row['POTENZA_uguale_350_KW_e_maggiore']: total_power += int(row['POTENZA_uguale_350_KW_e_maggiore']) * 350.0 if total_power: filtered_data.append({'location': row['toponimo'].lower(), 'power': total_power/1000, 'position': None}) return dict(data=filtered_data) config = AppConfig(minimal=True, root_controller=RootController()) config.renderers = ['json'] if __name__ == '__main__': import sys try: port = int(sys.argv[1]) except IndexError: port = 8080 print "Serving on port %d..." % port httpd = make_server('', port, config.make_wsgi_app()) httpd.serve_forever()
@expose("json") def queries(self, queries=1): num_queries = getQueryNum(queries) rp = partial(randint, 1, 10000) get = db_session.query(World).get worlds = [get(rp()).serialize() for _ in xrange(num_queries)] return json.dumps(worlds) @expose() def fortune(self): fortunes = db_session.query(Fortune).all() fortunes.append( Fortune(id=0, message="Additional fortune added at request time.")) fortunes.sort(key=attrgetter("message")) template = env.get_template("fortunes.html") return template.render(fortunes=fortunes) config = AppConfig(minimal=True, root_controller=RootController()) config.renderers.append("jinja") tg_app = config.make_wsgi_app() def app(env, start): try: return tg_app(env, start) finally: db_session.close()
def setup_class(cls): config = AppConfig(minimal=True, root_controller=RootController()) cls.wsgi_app = config.make_wsgi_app()
def _setup_google_music(): log.info('Connecting to Google Music') config = tg.config app_globals = config.tg.app_globals app_globals.gm = Webclient() app_globals.gm.login(config.gm.username, config.gm.password) song_sorting = lambda song: '%(artist)s-%(album)s-%(track)s' % song app_globals.library = sorted(app_globals.gm.get_all_songs(), key=song_sorting) config = AppConfig(minimal=True, root_controller=RootController()) config.renderers = ['json'] config.default_renderer = 'json' config.serve_static = True config.paths['static_files'] = '.' config.register_hook('startup', _setup_google_music) config.register_hook('startup', _setup_music_player) from wsgiref.simple_server import make_server import json config_options = {} with open('config.json') as config_file: config_options.update(json.load(config_file)) print "Serving on port 8080..." httpd = make_server('', 8080, config.make_wsgi_app(**config_options)) httpd.serve_forever()
@expose('json:', content_type='application/json') def timeline(self, **kw): f = open(TIMELINE_FILE) yield f.read() @expose('json:', content_type='application/json') def clusters(self, **kw): f = open(CLUSTERS_FILE) yield f.read() @expose('json:', content_type='application/json') def force(self, **kw): f = open(FORCE_FILE) yield f.read() config = AppConfig(minimal=True, root_controller=RootController()) #Only change since before is that we register the 'json' renderer #into our list of available renderers, so that we are able to #encode our responses as JSON config.renderers = ['json', 'jinja'] config.default_renderer = 'jinja' config.serve_static = True config['paths']['static_files'] = './' from wsgiref.simple_server import make_server print "Serving on port 8080..." httpd = make_server('', 8080, config.make_wsgi_app()) httpd.serve_forever()
def setup_class(cls): config = AppConfig(minimal=True, root_controller=RootController()) config['csrf.secret'] = 'MYSECRET' cls.wsgi_app = config.make_wsgi_app()
def test_render_missing_renderer(): conf = AppConfig(minimal=True) app = conf.make_wsgi_app() tg.render_template({}, 'gensh')
from tg import expose, TGController, AppConfig class RootController(TGController): @expose() def index(self): return "<h1>Hello World</h1>" class RootController(TGController): @expose() def index(self): return 'Hello World' @expose('hello.jinja') def hello(self, person=None): return dict(person=person) config = AppConfig(minimal=True, root_controller=RootController()) config.renderers = ['jinja'] config.serve_static = True config.paths['static_files'] = 'public' import webhelpers2 import webhelpers2.text config['helpers'] = webhelpers2 application = config.make_wsgi_app() print "Serving on port 80..." httpd = make_server('', 80, application) httpd.serve_forever()
world = db_session.query(World).get(id) world.randomNumber = rp() worlds.append(world.serialize()) db_session.commit() return json.dumps(worlds) @expose("json") def queries(self, queries=1): num_queries = getQueryNum(queries) rp = partial(randint, 1, 10000) get = db_session.query(World).get worlds = [get(rp()).serialize() for _ in xrange(num_queries)] return json.dumps(worlds) @expose() def fortune(self): fortunes = db_session.query(Fortune).all() fortunes.append(Fortune(id=0, message="Additional fortune added at request time.")) fortunes.sort(key=attrgetter("message")) for f in fortunes: f.message = bleach.clean(f.message) template = env.get_template("fortunes.html") return template.render(fortunes=fortunes) config = AppConfig(minimal=True, root_controller=RootController()) config.renderers.append("jinja") app = config.make_wsgi_app()
config.paths['static_files'] = 'static' from webassets.filter import register_filter from dukpy.webassets import BabelJSX register_filter(BabelJSX) import tgext.webassets as wa wa.plugme( config, options={ 'babel_modules_loader': 'umd' }, bundles={ 'bundle.js': wa.Bundle( 'js/react.js', 'js/react-dom.js', wa.Bundle( 'js/HelloWorld.jsx', filters='babeljsx', ), output='assets/bundle.js' ) } ) application = config.make_wsgi_app() from wsgiref.simple_server import make_server print("Serving on port 8080...") httpd = make_server('', 8080, application) httpd.serve_forever()
def index(self): redirect("list/") @expose("list.jinja") def list(self): onlyfiles = [f for f in listdir("public/video") if isfile(join("public/video", f))] return dict(message="this is the list", files=onlyfiles) @expose("view.jinja") def view(self, vId=None): if vId is None: return dict(message="The video ID is invalid") return dict( message=vId, vid_url="/video/" + vId, data_obj=[{"serie": 0, "time": 0, "gamma": 1, "delta": 3, "theta": 1, "beta": 2, "alpha": 1}], ) # return dict(message=vId, vid_url="/video/"+vId, data_obj = [{"serie":0, "time":0, "gamma":1, "delta":3, "theta":1, "beta":2, "alpha":1}] ) config = AppConfig(minimal=True, root_controller=RootController()) config.renderers = ["jinja"] config.serve_static = True config.paths["static_files"] = "public" application = config.make_wsgi_app() print("Serving on port 8080...") httpd = make_server("", 8080, config.make_wsgi_app()) httpd.serve_forever()
def init_model(engine): DBSession.configure(bind=engine) DeclarativeBase.metadata.create_all( engine) # Create tables if they do not exist config['model'] = Bunch(DBSession=DBSession, init_model=init_model) from sqlalchemy.ext.declarative import declarative_base DeclarativeBase = declarative_base() from sqlalchemy import Column, Integer, DateTime, String from datetime import datetime class Conteiner(DeclarativeBase): __tablename__ = 'conteineres' id = Column(Integer, primary_key=True) timestamp = Column(DateTime, nullable=False, default=datetime.utcnow) numero = Column(String(50), nullable=False) application = config.make_wsgi_app() print("Serving on port 8080...") httpd = make_server('', 8080, config.make_wsgi_app()) httpd.serve_forever()
def setup_class(cls): config = AppConfig(minimal=True, root_controller=RootController()) config.paths['static_files'] = PATH_TO_STORAGE cls.wsgi_app = config.make_wsgi_app()