Пример #1
0
def configure_app():
    app_cfg = AppConfig(minimal=True)
    app_cfg.renderers = ['genshi']
    app_cfg.default_renderer = 'genshi'
    app_cfg.use_dotted_templatenames = True
    app_cfg.package = FakeAppPackage()
    app_cfg.use_toscawidgets2 = True
    app_cfg['tw2.enabled'] = True
    app_cfg.sa_auth.authmetadata = TestAuthMetadata()
    app_cfg['beaker.session.secret'] = 'SECRET'
    app_cfg.auth_backend = 'sqlalchemy'
    app_cfg.sa_auth.cookie_secret = 'SECRET'
    app_cfg.package.model = FakeSQLAModel()
    app_cfg.use_sqlalchemy = True
    app_cfg['sqlalchemy.url'] = 'sqlite://'
    app_cfg.use_transaction_manager = True
    app_cfg['tm.enabled'] = True
    app_cfg.model = app_cfg.package.model
    app_cfg.DBSession = app_cfg.package.model.DBSession

    plug(app_cfg,
         'calendarevents',
         event_types=[FakeEventType()],
         global_models=False,
         plug_bootstrap=False,
         form_instance=calendar_form)

    # This is to reset @cached_properties so they get reconfigured for new backend

    return app_cfg
Пример #2
0
 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)
Пример #3
0
 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)
Пример #4
0
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()
Пример #5
0
def configure_app(using, create_form=True):
    # Simulate starting configuration process from scratch
    milestones._reset_all()

    app_cfg = AppConfig(minimal=True)
    app_cfg.renderers = ['kajiki']
    app_cfg.default_renderer = 'kajiki'
    app_cfg.use_dotted_templatenames = True
    app_cfg.package = FakeAppPackage()
    app_cfg.use_toscawidgets2 = True
    app_cfg['tw2.enabled'] = True
    app_cfg.sa_auth.authmetadata = TestAuthMetadata()
    app_cfg['beaker.session.secret'] = app_cfg['session.secret'] = 'SECRET'
    app_cfg['mail.debugmailer'] = 'dummy'

    if using == 'sqlalchemy':
        app_cfg.auth_backend = 'sqlalchemy'
        app_cfg.package.model = FakeSQLAModel()
        app_cfg.use_sqlalchemy = True
        app_cfg['sqlalchemy.url'] = 'sqlite://'
        app_cfg.use_transaction_manager = True
        app_cfg['tm.enabled'] = True
    elif using == 'ming':
        app_cfg.auth_backend = 'ming'
        app_cfg.package.model = FakeMingModel()
        app_cfg.use_ming = True
        app_cfg['ming.url'] = 'mim:///testresetpassword'
    else:
        raise ValueError('Unsupported backend')

    # Reset the Sprox provider on every change of configuration.
    from resetpassword import model as resetpassword_model
    resetpassword_model.provider._provider = None

    app_cfg.model = app_cfg.package.model
    app_cfg.DBSession = app_cfg.package.model.DBSession

    # CUSTOM resetpassword options
    app_cfg['resetpassword.email_sender'] = '*****@*****.**'

    plug(app_cfg, 'tgext.mailer', plug_bootstrap=True, debugmailer='dummy')
    plug(
        app_cfg,
        'resetpassword',
        plug_bootstrap=False,
        reset_password_form_instance=resetpassword_form
        if create_form else None,
        new_password_form_instance=newpassword_form if create_form else None,
    )

    return app_cfg
Пример #6
0
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()
Пример #7
0
def configure_app(using):
    # Simulate starting configuration process from scratch
    milestones._reset_all()

    app_cfg = AppConfig(minimal=True)
    app_cfg.renderers = ['kajiki']
    app_cfg.default_renderer = 'kajiki'
    app_cfg.use_dotted_templatenames = True
    app_cfg.package = FakeAppPackage()
    app_cfg.use_toscawidgets2 = True
    app_cfg['tw2.enabled'] = True
    app_cfg.sa_auth.authmetadata = TestAuthMetadata()
    app_cfg['beaker.session.secret'] = app_cfg['session.secret'] = 'SECRET'
    app_cfg.auth_backend = 'ming'
    app_cfg['mail.debugmailer'] = "dummy"

    if using == 'sqlalchemy':
        app_cfg.package.model = FakeSQLAModel()
        app_cfg.use_sqlalchemy = True
        app_cfg['sqlalchemy.url'] = 'sqlite://'
        app_cfg.use_transaction_manager = True
        app_cfg['tm.enabled'] = True
        app_cfg.SQLASession = app_cfg.package.model.DBSession
    elif using == 'ming':
        app_cfg.package.model = FakeMingModel()
        app_cfg.use_ming = True
        app_cfg['ming.url'] = 'mim:///mailtemapltes'
        app_cfg.MingSession = app_cfg.package.model.DBSession
    else:
        raise ValueError('Unsupported backend')

    app_cfg.model = app_cfg.package.model
    app_cfg.DBSession = app_cfg.package.model.DBSession

    # Guarantee that the same form is used between multiple
    # configurations of TGApps. Otherwise the validated
    # form would be different from the displayed one.

    plug(app_cfg, 'tgext.mailer', plug_bootstrap=True, debugmailer='dummy')
    plug(app_cfg,
         'tgext.asyncjob',
         plug_bootstrap=True,
         app_globals=app_cfg['app_globals'])
    # it is important that tgext.mailer and tgext.asyncjob are plugged
    # before mailtemplates or not plugged at all as mailtemplates plugs them
    plug(app_cfg, 'mailtemplates', plug_bootstrap=True, default_language='EN')
    return app_cfg
Пример #8
0
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()
Пример #9
0
def configure_app(using):
    # Simulate starting configuration process from scratch
    milestones._reset_all()

    app_cfg = AppConfig(minimal=True)
    app_cfg.renderers = ['kajiki']
    app_cfg.default_renderer = 'kajiki'
    app_cfg.use_dotted_templatenames = True
    app_cfg.package = FakeAppPackage()
    app_cfg.use_toscawidgets2 = True
    app_cfg.sa_auth.authmetadata = TestAuthMetadata()
    app_cfg['beaker.session.secret'] = app_cfg['session.secret'] = 'SECRET'
    app_cfg.auth_backend = 'ming'
    app_cfg['mail.debugmailer'] = 'dummy'

    if using == 'sqlalchemy':
        app_cfg.package.model = FakeSQLAModel()
        app_cfg.use_sqlalchemy = True
        app_cfg['sqlalchemy.url'] = 'sqlite://'
        app_cfg.use_transaction_manager = True
    elif using == 'ming':
        app_cfg.package.model = FakeMingModel()
        app_cfg.use_ming = True
        app_cfg['ming.url'] = 'mim:///testregistration'
    else:
        raise ValueError('Unsupported backend')

    app_cfg.model = app_cfg.package.model
    app_cfg.DBSession = app_cfg.package.model.DBSession

    # CUSTOM registration options
    app_cfg['registration.email_sender'] = '*****@*****.**'

    from registration.lib import send_email, get_form

    # Guarantee that the same form is used between multiple
    # configurations of TGApps. Otherwise the validated
    # form would be different from the displayed one.
    plug_args = {}
    if '_pluggable_registration_config' in config:
        plug_args['form_instance'] = get_form()

    plug(app_cfg, 'tgext.mailer', plug_bootstrap=True, debugmailer='dummy')
    plug(app_cfg, 'registration', plug_bootstrap=False, **plug_args)
    return app_cfg
Пример #10
0
    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()
Пример #11
0
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()
Пример #12
0
    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()
Пример #13
0
def configure_app(using):
    # Simulate starting configuration process from scratch
    milestones._reset_all()

    app_cfg = AppConfig(minimal=True)
    app_cfg.renderers = ['kajiki']
    app_cfg.default_renderer = 'kajiki'
    app_cfg.use_dotted_templatenames = True
    app_cfg.package = FakeAppPackage()
    app_cfg.use_toscawidgets2 = True
    app_cfg['beaker.session.secret'] = app_cfg['session.secret'] = 'SECRET'
    app_cfg['mail.debugmailer'] = "dummy"

    if using == 'sqlalchemy':
        app_cfg.auth_backend = 'sqlalchemy'
        app_cfg.package.model = FakeSQLAModel()
        app_cfg.use_sqlalchemy = True
        app_cfg['sqlalchemy.url'] = 'sqlite://'
        app_cfg.use_transaction_manager = True
        app_cfg.SQLASession = app_cfg.package.model.DBSession
    elif using == 'ming':
        app_cfg.auth_backend = 'ming'
        app_cfg.package.model = FakeMingModel()
        app_cfg.use_ming = True
        app_cfg['ming.url'] = 'mim:///userprofile'
        app_cfg.MingSession = app_cfg.package.model.DBSession
    else:
        raise ValueError('Unsupported backend')

    app_cfg.model = app_cfg.package.model
    app_cfg.DBSession = app_cfg.package.model.DBSession
    app_cfg.sa_auth.authmetadata = TestAuthMetadata()

    # Guarantee that the same form is used between multiple
    # configurations of TGApps. Otherwise the validated
    # form would be different from the displayed one.

    app_cfg['userprofile.email_sender'] = '[email protected]'

    plug(app_cfg, 'userprofile', plug_bootstrap=True)
    return app_cfg
Пример #14
0
        output += "  <input type=\"file\" name=\"file1\"><br>"
        output += "  <input type=\"submit\" value=\"Submit\">"
        output += " </form> "

        return output

    @expose()
    def conteiner(self, numero=None):
        DBSession.add(Conteiner(numero=numero or ''))
        DBSession.commit()
        return "OK"


config = AppConfig(minimal=True, root_controller=RootController())

config.renderers = ['kajiki']
config.serve_static = True
config.paths['static_files'] = 'img'
config['use_sqlalchemy'] = True
config['sqlalchemy.url'] = 'sqlite:///devdata.db'
from tg.util import Bunch
from sqlalchemy.orm import scoped_session, sessionmaker

DBSession = scoped_session(sessionmaker(autoflush=True, autocommit=False))


def init_model(engine):
    DBSession.configure(bind=engine)
    DeclarativeBase.metadata.create_all(
        engine)  # Create tables if they do not exist
Пример #15
0
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()
Пример #16
0
                    'clusters':clusters,
                    'cluster_counts':cluster_counts,
                    'degree_distribution':degree_distribution,
                    'degree':foaf_graph.degree(),
                    'top10':top10
                }
                foaf_data = json.dumps(infos)
                data_file.write(foaf_data)
                return foaf_data

    @expose(content_type='application/json')
    def graph(self, **kw):
        with closing(open('graph_cache.json', 'w')) as graph_file:
            foaf_graph = retrieve_foaf(FBTOKEN)                             
            foaf_graph_json = jg.dumps(foaf_graph)
            graph_file.write(foaf_graph_json)
            return foaf_graph_json
 
config = AppConfig(minimal=True, root_controller=RootController())
config.serve_static = True
config.paths['static_files'] = './'

config.renderers = ['jinja', 'json']
config.default_renderer = 'jinja'

application = config.make_wsgi_app()

print 'Serving on port 8080...'
httpd = make_server('', 8080, application)
httpd.serve_forever()
Пример #17
0
                    if total_power:
                        pos = None
                        if addr_cache.has_key(row['toponimo']):
                            pos = addr_cache[row['toponimo']]

                        filtered_data.append({
                            'location':
                            row['toponimo'].lower(),
                            'power':
                            total_power / 1000,
                            'position':
                            None
                        })

        return dict(data=filtered_data)

    @expose()
    def save_geocode(self, addr, lng, lat):
        addr_cache[addr.encode('utf-8')] = (lng, lat)
        addr_cache.sync()
        return 'OK'


config = AppConfig(minimal=True, root_controller=RootController())
config.renderers = ['json']

print "Serving on port 8080..."
httpd = make_server('', 8080, config.make_wsgi_app())
httpd.serve_forever()
Пример #18
0
    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()
Пример #19
0
    @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()
Пример #20
0
                        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:
                        pos = None
                        if addr_cache.has_key(row['toponimo']):
                            pos = addr_cache[row['toponimo']]

                        filtered_data.append({'location': row['toponimo'].lower(), 'power': total_power/1000, 'position': None})
            
        return dict(data=filtered_data)

    @expose()
    def save_geocode(self, addr, lng, lat):
        addr_cache[addr.encode('utf-8')] = (lng, lat)
        addr_cache.sync()
        return 'OK'

config = AppConfig(minimal=True, root_controller=RootController())
config.renderers = ['json']

print "Serving on port 8080..."
httpd = make_server('', 8080, config.make_wsgi_app())
httpd.serve_forever()

Пример #21
0
        # a graph with at least count entries (by default 40)
        data = []
        for i in range(count):
            data.append(psutil.cpu_percent(interval=0.1))

        # Here we encode our Python list as a Javascript
        # array of numbers, if you try to print the jsdata
        # you will see that is the Javascript code for an array.
        # This way we can use it from our javascript script
        jsdata = json.dumps(data)

        # If you expose a template, the controller is required
        # to return a dictionary with inside any data
        # that has to be available to the template
        return dict(data=jsdata, num=len(data))


config = AppConfig(minimal=True, root_controller=RootController())

# Major change from step 0 is that we register the Jinja
# template engine so that we can render our index.html file
config.renderers = ['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()
Пример #22
0
convert them into boolean, for example, you should use the
:func:`paste.deploy.converters.asbool` function, as in::
    
    from paste.deploy.converters import asbool
    setting = asbool(global_conf.get('the_setting'))
 
"""
from tg import AppConfig

import trine
from trine import model
from trine.lib import helpers
from trine.lib.app_globals import Globals

base_config = AppConfig()
base_config.renderers = []

# True to prevent dispatcher from striping extensions
# For example /socket.io would be served by "socket_io" method instead of "socket"
base_config.disable_request_extensions = False

# Set None to disable escaping punctuation characters to "_" when dispatching methods.
# Set to a function to provide custom escaping.
base_config.dispatch_path_translator = True
base_config.prefer_toscawidgets2 = True

base_config.package = trine

#Enable json in expose
base_config.renderers.append('json')
#Enable genshi in expose to have a lingua franca for extensions and pluggable apps