def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    global check_username

    check_username = lambda username, password:\
        settings['gmusicapi_username'] == username and\
        settings['gmusicapi_password'] == password
    if not gm.login(settings['gmusicapi_username'],
                    settings['gmusicapi_password']):
        logger.warn("Unable to login to Google Music!")
        exit()
    if not wc.login(settings['gmusicapi_username'],
                    settings['gmusicapi_password']):
        logger.warn("Unable to login to Google Music!")
        exit()

    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    set_cache_regions_from_settings(settings)
    config = Configurator(settings=settings)
    config.include('pyramid_chameleon')
    config.include('gmusic.views')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.scan()
    return config.make_wsgi_app()
Example #2
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    authentication_policy = AuthTktAuthenticationPolicy('seekrit',
            callback=groupfinder)
    authorization_policy = ACLAuthorizationPolicy()
    config = Configurator(
        settings = settings
        , authentication_policy = authentication_policy
        , authorization_policy=authorization_policy
    )

    engine = engine_from_config(settings, 'sqlalchemy.')

    DBSession.configure(bind=engine)

    config.registry.registerUtility(DBSession, IDBSession)

    config.override_asset(
        to_override='hiero:templates/blog_index.mako',
        override_with='sontek:templates/blog_index.mako'
    )

    config.override_asset(
        to_override='hiero:templates/entry_detail.mako',
        override_with='sontek:templates/entry_detail.mako'
    )

    config.include('sontek.routes')

    config.scan()
    return config.make_wsgi_app()
Example #3
0
class Test_model_url_filter(unittest.TestCase):
    def setUp(self):
        self.environment = Environment()
        from pyramid_jinja2.filters import model_url_filter
        self.environment.filters['model_url'] = model_url_filter
        from pyramid.config import Configurator
        self.config = Configurator(autocommit=True)
        self.config.begin(request=DummyRequest())

    def tearDown(self):
        self.config.end()

    def _callFUT(self, context, tmpl):
        tmpl = self.environment.from_string(tmpl)
        return tmpl.render(**context)


    def test_filter(self):
        model = DummyModel()
        rendered = self._callFUT({'model':model}, '{{model|model_url}}')
        self.assertEqual(rendered, 'http://example.com/dummy/')

    def test_filter_with_elements(self):
        model = DummyModel()
        rendered = self._callFUT({'model':model}, "{{model|model_url('edit')}}")
        self.assertEqual(rendered, 'http://example.com/dummy/edit')
Example #4
0
 def test_it(self):
     from pyramid.config import Configurator
     from pyramid_handlers import add_handler
     from pyramid_handlers import includeme
     c = Configurator(autocommit=True)
     c.include(includeme)
     self.assertTrue(c.add_handler.__func__.__docobj__ is add_handler)
Example #5
0
    def test_pyramid_directive(self):
        from pyramid.config import Configurator

        config = Configurator()
        config.include('ptah')

        self.assertTrue(hasattr(config, 'ptah_migrate'))
Example #6
0
def main(global_config, **settings):
    config = Configurator(settings=settings)
    config.include('pyramid_chameleon')
    config.add_route('home', '/')
    config.add_route('hello', '/howdy')
    config.scan('.views')
    return config.make_wsgi_app()
Example #7
0
def registerDummySecurityPolicy(userid=None, groupids=(), permissive=True):
    """ Registers a pair of faux :app:`Pyramid` security policies:
    a :term:`authentication policy` and a :term:`authorization
    policy`.

    The behavior of the registered :term:`authorization policy`
    depends on the ``permissive`` argument.  If ``permissive`` is
    true, a permissive :term:`authorization policy` is registered;
    this policy allows all access.  If ``permissive`` is false, a
    nonpermissive :term:`authorization policy` is registered; this
    policy denies all access.

    The behavior of the registered :term:`authentication policy`
    depends on the values provided for the ``userid`` and ``groupids``
    argument.  The authentication policy will return the userid
    identifier implied by the ``userid`` argument and the group ids
    implied by the ``groupids`` argument when the
    :func:`pyramid.security.authenticated_userid` or
    :func:`pyramid.security.effective_principals` APIs are used.

    This function is most useful when testing code that uses the APIs named
    :func:`pyramid.security.has_permission`,
    :func:`pyramid.security.authenticated_userid`,
    :func:`pyramid.security.unauthenticated_userid`,
    :func:`pyramid.security.effective_principals`, and
    :func:`pyramid.security.principals_allowed_by_permission`.
    """
    registry = get_current_registry()
    config = Configurator(registry=registry)
    result = config.testing_securitypolicy(userid=userid, groupids=groupids,
                                           permissive=permissive)
    config.commit()
    return result
 def _make_config(self, settings={}):
     all_settings = self.DEFAULT_SETTINGS.copy()
     all_settings.update(settings)
     config = Configurator(settings=all_settings)
     config.include("tokenserver")
     config.commit()
     return config
Example #9
0
def main(argv=sys.argv):
    # Usage and configuration
    if len(argv) != 2:
        usage(argv)
    config_uri = argv[1]
    setup_logging(config_uri)
    settings = get_appsettings(config_uri)
    config = Configurator(settings=settings)
    config.include('pyramid_sqlalchemy')

    # Make the database with schema and default data
    with transaction.manager:
        metadata.create_all()
        root = RootFolder(name='',
                      title='Moonbase Demo',
                      __acl__=[
                          ['Allow', ['paul'], 'view']
                      ]
                      )
        Session.add(root)
        f1 = root['f1'] = Folder(
            title='Folder 1',
            __acl__=[
                ['Allow', ['shane'], 'view']
            ]
        )
        f1['da'] = Document(title='Document 1A')
Example #10
0
 def make_app(cls, settings=None, config=None):
     settings = cls.get_app_settings(settings)
     config = Configurator(settings=settings)
     for event_cls in cls.subscribed:
         config.add_subscriber(cls.listener, event_cls)
     config.commit()
     return super().make_app(settings=settings, config=config)
Example #11
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """

    load_project_settings()

    session_factory = UnencryptedCookieSessionFactoryConfig(settings.get('session.secret', 'hello'))

    engine = engine_from_config(settings, 'sqlalchemy.')
    db.configure(bind=engine)
    config = Configurator(session_factory=session_factory, settings=settings)
    config.add_tween('droneos_ui.auth.authenticator')
    config.include('pyramid_handlers')
    config.add_view('pyramid.view.append_slash_notfound_view',
                context='pyramid.httpexceptions.HTTPNotFound')

    add_admin_handler(config, db, get_models(droneos_ui), 'admin.', '/admin', AdminController)

    application_routes(config)
    configure_app_routes(config)

    all_apps = get_submodules(apps)

    ignored_apps = []
    for app in all_apps:
        if app['is_package'] and app['name'] not in enabled_apps:
            ignored_apps.append('.apps.' + app['name'])

    config.scan(ignore=ignored_apps)

    return config.make_wsgi_app()
class TestServiceDefinition(unittest2.TestCase):

    def setUp(self):
        if not metlog:
            raise(unittest2.SkipTest('no metlog'))
        mozconfig = Config(StringIO(dedent("""
        [test1]
        backend = mozsvc.metrics.MetlogPlugin
        sender_class=metlog.senders.DebugCaptureSender
        """)))
        settings = {"config": mozconfig}
        self.plugin = load_from_config("test1", mozconfig)
        self.config = Configurator(settings=settings)
        self.config.include("cornice")
        self.config.scan("mozsvc.tests.test_service_definition")
        self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))

    def tearDown(self):
        testing.tearDown()

    def test_decorated_view_fn(self):
        # passing a decorator in to the service api call should result in a
        # decorated view callable
        resp = self.app.get("/service3")
        self.assertEquals(resp.json, {'test': 'succeeded', 'wrapped0': 'yes'})

    def test_stacked_decorated_view(self):
        # passing a decorator in to the service api call should result in a
        # decorated view callable, ordering of the particular decorators
        # shouldn't break things
        resp = self.app.get("/service4")
        self.assertEquals(resp.json, {'test': 'succeeded', 'wrapped0': 'yes'})

        resp = self.app.get("/service5")
        self.assertEquals(resp.json, {'test': 'succeeded', 'wrapped0': 'yes'})
Example #13
0
def app():
    config = Configurator()
    config.include('pyramid_wiring')

    graph = Graph()
    graph.register_scope(RequestScope, RequestScope())
    class Counter(object):
        def __init__(self):
            self.count = 1
    graph.register_provider('counter', FactoryProvider(Counter, scope=RequestScope))
    config.set_object_graph(graph)

    def count(request, counter=injected('counter')):
        # Increment the counter
        count = counter.count
        counter.count += 1

        # Get the counter from the graph again and make sure it's the same
        assert graph.get('counter') is counter

        return count
    config.add_route('count', '/count')
    config.add_view(count, route_name='count', renderer='string')

    return TestApp(config.make_wsgi_app())
Example #14
0
def registerResources(resources):
    """ Registers a dictionary of :term:`resource` objects that can be
    resolved via the :func:`pyramid.traversal.find_resource` API.

    The :func:`pyramid.traversal.find_resource` API is called with a
    path as one of its arguments.  If the dictionary you register when
    calling this method contains that path as a string key
    (e.g. ``/foo/bar`` or ``foo/bar``), the corresponding value will
    be returned to ``find_resource`` (and thus to your code) when
    :func:`pyramid.traversal.find_resource` is called with an
    equivalent path string or tuple.

    .. warning:: This API is deprecated as of :app:`Pyramid` 1.0.
       Instead use the
       :meth:`pyramid.config.Configurator.testing_resources`
       method in your unit and integration tests.

    .. note:: For ancient backward compatibility purposes, this API can also
       be accessed as :func:`pyramid.testing.registerModels`.
    """
    registry = get_current_registry()
    config = Configurator(registry=registry)
    result = config.testing_resources(resources)
    config.commit()
    return result
Example #15
0
def registerEventListener(event_iface=None):
    """ Registers an :term:`event` listener (aka :term:`subscriber`)
    listening for events of the type ``event_iface``.  This method
    returns a list object which is appended to by the subscriber
    whenever an event is captured.

    When an event is dispatched that matches ``event_iface``, that
    event will be appended to the list.  You can then compare the
    values in the list to expected event notifications.  This method
    is useful when testing code that wants to call
    :meth:`pyramid.registry.Registry.notify`,
    :func:`zope.component.event.dispatch` or
    :func:`zope.component.event.objectEventNotify`.

    The default value of ``event_iface`` (``None``) implies a
    subscriber registered for *any* kind of event.

    .. warning:: This API is deprecated as of :app:`Pyramid` 1.0.
       Instead use the
       :meth:`pyramid.config.Configurator.testing_add_subscriber`
       method in your unit and integration tests.
    """
    registry = get_current_registry()
    config = Configurator(registry=registry)
    result = config.testing_add_subscriber(event_iface)
    config.commit()
    return result
Example #16
0
def registerSubscriber(subscriber, iface=Interface):
    """ Register a ZCA subscriber component.

    The ``subscriber`` argument specifies the implementation of the
    subscriber component (often a function).

    The ``iface`` argument is the interface type for which the
    subscriber will be registered (:class:`zope.interface.Interface`
    by default). If ``iface`` is not a tuple or list, it will be
    converted to a one-tuple before being passed to the underlying ZCA
    :meth:`pyramid.registry.registerHandler` method.

    See `The ZCA book <http://www.muthukadan.net/docs/zca.html>`_ for
    more information about ZCA subscribers.

    .. warning:: This API is deprecated as of :app:`Pyramid` 1.0.
       Instead use the
       :meth:`pyramid.config.Configurator.add_subscriber`
       method in your unit and integration tests.
    """
    registry = get_current_registry()
    config = Configurator(registry)
    result = config.add_subscriber(subscriber, iface=iface)
    config.commit()
    return result
Example #17
0
def registerSettings(dictarg=None, **kw):
    """Register one or more 'setting' key/value pairs.  A setting is
    a single key/value pair in the dictionary-ish object returned from
    the API :attr:`pyramid.registry.Registry.settings`.

    You may pass a dictionary::

       registerSettings({'external_uri':'http://example.com'})

    Or a set of key/value pairs::

       registerSettings(external_uri='http://example.com')

    Use of this function is required when you need to test code that calls
    the :attr:`pyramid.registry.Registry.settings` API and which uses return
    values from that API.

    .. warning:: This API is deprecated as of :app:`Pyramid` 1.0.
       Instead use the
       :meth:`pyramid.config.Configurator.add_settings`
       method in your unit and integration tests.
    """
    registry = get_current_registry()
    config = Configurator(registry=registry)
    config.add_settings(dictarg, **kw)
Example #18
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)

    Base.metadata.bind = engine

    session_factory = session_factory_from_settings(settings)

    authn_policy = AuthTktAuthenticationPolicy('s0secret', callback=groupfinder, hashalg='md5')
    #authn_policy = AuthTktAuthenticationPolicy('s0secret')
    authz_policy = ACLAuthorizationPolicy()

    config = Configurator(
        settings=settings,
        root_factory=RootFactory,
        authentication_policy=authn_policy,
        authorization_policy=authz_policy,
        session_factory=session_factory
        )

    # since version 1.5 templating is not included by default
    config.include('pyramid_chameleon')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.include(addroutes)
    config.scan()

    return config.make_wsgi_app()
Example #19
0
    def test_parent_queryset_es(self):
        from pyramid.config import Configurator
        from ramses.acl import BaseACL
        config = Configurator()
        config.include('nefertari')
        root = config.get_root_resource()
        user = root.add(
            'user', 'users', id_name='username',
            view=views.ESBaseView, factory=BaseACL)
        user.add(
            'story', 'stories', id_name='prof_id',
            view=views.ESBaseView, factory=BaseACL)
        view_cls = root.resource_map['user:story'].view

        request = Mock(
            registry={'foo': 'bar'},
            path='/foo/foo',
            matchdict={'username': '******', 'prof_id': 4},
            accept=[''], method='GET'
        )
        request.params.mixed.return_value = {'foo1': 'bar1'}
        request.blank.return_value = request
        stories_view = view_cls(
            request=request,
            context={},
            _query_params={'foo1': 'bar1'},
            _json_params={'foo2': 'bar2'},)

        parent_view = stories_view._resource.parent.view
        with patch.object(parent_view, 'get_item_es') as get_item_es:
            parent_view.get_item_es = get_item_es
            result = stories_view._parent_queryset_es()
            get_item_es.assert_called_once_with(username='******')
            assert result == get_item_es().stories
Example #20
0
def _apply_parent_actions(parent_registry):
    toolbar_app = parent_registry.queryUtility(IToolbarWSGIApp)
    if toolbar_app is None:
        # this registry does not have a debugtoolbar attached
        return

    toolbar_registry = toolbar_app.registry

    # inject the BeforeRender subscriber after the application is created
    # and all other subscribers are registered in hopes that this will be
    # the last subscriber in the chain and will be able to see the effects
    # of all previous subscribers on the event
    parent_config = Configurator(registry=parent_registry, introspection=False)

    parent_config.add_subscriber(
        'pyramid_debugtoolbar.toolbar.beforerender_subscriber',
        'pyramid.events.BeforeRender',
    )

    actions = toolbar_registry.queryUtility(IParentActions, default=[])
    for action in actions:
        action(parent_config)

    # overwrite actions after they have been applied to avoid applying them
    # twice - but leave it as a new list incase someone adds more actions later
    # and calls config.make_wsgi_app() again... this would mainly be necessary
    # for tests that call config.make_wsgi_app() multiple times.
    toolbar_registry.registerUtility([], IParentActions)

    parent_config.commit()
Example #21
0
    def _makeOne(self, autocommit=True):
        from pyramid.config import Configurator
        from pyramid_handlers import add_handler

        config = Configurator(autocommit=autocommit)
        config.add_directive("add_handler", add_handler)
        return config
Example #22
0
 def _makeOne(self, autocommit=True):
     from pyramid.config import Configurator
     import pyramid_handlers
     from papyrus import add_papyrus_routes
     config = Configurator(autocommit=autocommit)
     config.add_directive('add_papyrus_routes', add_papyrus_routes)
     return config
Example #23
0
    def test_handle_submit_key_expired(self):
        reg = get_current_registry()
        config = Configurator(reg)
        renderer = config.testing_add_template('templates/reset_failed.pt')
        request = self.request
        request.params['key'] = '0' * 40
        self._setupUsers()
        context = self.context
        context['profiles'] = testing.DummyModel()
        profile = context['profiles']['me'] = testing.DummyModel()
        profile.password_reset_key = '0' * 40
        controller = self._makeOne(context, request)
        converted = {'login': '******'}
        # first w/ no profile reset time
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Key Expired')

        # now w/ expired key
        renderer = config.testing_add_template('templates/reset_failed.pt')
        from karl.views.resetpassword import max_reset_timedelta
        import datetime
        keytime = datetime.datetime.now() - max_reset_timedelta
        profile.password_reset_time = keytime
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Key Expired')
Example #24
0
    def test___call__bad_key(self):
        # register dummy renderer for the email template
        reg = get_current_registry()
        config = Configurator(reg)
        renderer = config.testing_add_template('templates/reset_failed.pt')

        request = self.request
        request.layout_manager = mock.Mock()
        # no key
        controller = self._makeOne(self.context, request)
        response = controller()
        from pyramid.response import Response
        self.assertEqual(response.__class__, Response)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset URL Problem')

        # reset renderer.api value so we know the test is useful
        renderer = config.testing_add_template('templates/reset_failed.pt')
        # key of wrong length
        request.params['key'] = 'foofoofoo'
        controller = self._makeOne(self.context, request)
        response = controller()
        from pyramid.response import Response
        self.assertEqual(response.__class__, Response)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset URL Problem')
Example #25
0
    def test_handle_submit_wrong_key(self):
        reg = get_current_registry()
        config = Configurator(reg)
        renderer = config.testing_add_template('templates/reset_failed.pt')
        request = self.request
        request.params['key'] = '0' * 40
        self._setupUsers()
        context = self.context
        context['profiles'] = testing.DummyModel()
        context['profiles']['me'] = testing.DummyModel()
        controller = self._makeOne(context, request)
        converted = {'login': '******'}
        # first w/ no profile reset key
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Problem')

        # now w/ wrong profile reset key
        renderer = config.testing_add_template('templates/reset_failed.pt')
        context['profiles']['me'].password_reset_key = '1' * 40
        response = controller.handle_submit(converted)
        self.failUnless(hasattr(renderer, 'api'))
        self.assertEqual(renderer.api.page_title,
                         'Password Reset Confirmation Problem')
Example #26
0
def get_app(
        tool_definition, data_folder, website_name=None, website_owner=None,
        website_url=None):
    settings = {
        'data.folder': data_folder,
        'website.name': website_name or WEBSITE['name'],
        'website.owner': website_owner or WEBSITE['owner'],
        'website.url': website_url or WEBSITE['url'],
        'website.root_assets': [
            'invisibleroads_posts:assets/favicon.ico',
            'invisibleroads_posts:assets/robots.txt',
        ],
        'uploads.upload.id.length': 32,
        'client_cache.http.expiration_time': 3600,
        'jinja2.directories': 'crosscompute:templates',
        'jinja2.lstrip_blocks': True,
        'jinja2.trim_blocks': True,
    }
    settings['tool_definition'] = tool_definition
    config = Configurator(settings=settings)
    config.include('invisibleroads_posts')
    includeme(config)
    add_routes(config)
    add_routes_for_fused_assets(config)
    return config.make_wsgi_app()
Example #27
0
def create_app(settings):
    from horus import groupfinder
    from pyramid.config import Configurator
    from pyramid.authentication import AuthTktAuthenticationPolicy
    from pyramid.authorization import ACLAuthorizationPolicy

    settings.setdefault('horus.activation_class', 'h.models.Activation')
    settings.setdefault('horus.user_class', 'h.models.User')

    authn_policy = AuthTktAuthenticationPolicy(
        settings['auth.secret'],
        callback=groupfinder
    )

    authz_policy = ACLAuthorizationPolicy()

    config = Configurator(
        settings=settings,
        authentication_policy=authn_policy,
        authorization_policy=authz_policy,
        root_factory='h.resources.RootFactory'
    )

    config.include(includeme)
    return config.make_wsgi_app()
Example #28
0
 def test_handle_submit_utf8_password(self):
     password = u'password\xe1'
     reg = get_current_registry()
     config = Configurator(reg)
     renderer = config.testing_add_template('templates/reset_complete.pt')
     request = self.request
     request.params['key'] = '0' * 40
     self._setupUsers()
     context = self.context
     context['profiles'] = testing.DummyModel()
     profile = context['profiles']['me'] = testing.DummyModel()
     profile.password_reset_key = '0' * 40
     controller = self._makeOne(context, request)
     converted = {'login': '******', 'password': password}
     import datetime
     keytime = datetime.datetime.now()
     profile.password_reset_time = keytime
     response = controller.handle_submit(converted)
     self.failUnless(hasattr(renderer, 'api'))
     self.assertEqual(renderer.api.page_title,
                      'Password Reset Complete')
     renderer.assert_(login='******', password=password)
     self.failUnless(profile.password_reset_key is None)
     self.failUnless(profile.password_reset_time is None)
     user = self.context.users.get(login='******')
     from repoze.who.plugins.zodb.users import get_sha_password
     self.assertEqual(user['password'], get_sha_password(password.encode('utf8')))
Example #29
0
File: rtd.py Project: baloon11/npui
def main(argv=sys.argv):
	if len(argv) != 2:
		usage(argv)
	config_uri = argv[1]
	setup_logging(config_uri)
	settings = get_appsettings(config_uri)
	engine = engine_from_config(settings, 'sqlalchemy.')
	DBSession.configure(bind=engine)
	cache.cache = cache.configure_cache(settings)

	config = Configurator(
		settings=settings,
		root_factory=RootFactory,
		locale_negotiator=locale_neg
	)
	config.add_route_predicate('vhost', VHostPredicate)
	config.add_view_predicate('vhost', VHostPredicate)

	mmgr = config.registry.getUtility(IModuleManager)
	mmgr.load('core')
	mmgr.load_enabled()

	rts = rt.configure(mmgr, config.registry)
	app = rts.app()
	rt.run(rts, app)
Example #30
0
def main(global_config, **settings):
    """ This function returns a WSGI application.
    
    It is usually called by the PasteDeploy framework during 
    ``paster serve``.
    """
    settings = dict(settings)
    settings.setdefault('jinja2.i18n.domain', 'hello_world')

    # Start Sphinx Include 2
    my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet')
    config = Configurator(root_factory=get_root, settings=settings,
                          session_factory=my_session_factory)
    # End Sphinx Include 2
    config.add_translation_dirs('locale/')
    # Start Include
    config.include('pyramid_jinja2')
    # End Include


    config.add_static_view('static', 'static')
    config.add_view('hello_world.views.my_view',
                    context='hello_world.models.MyModel', 
                    renderer="mytemplate.jinja2")

    return config.make_wsgi_app()
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application."""
    settings["sqlalchemy.url"] = os.environ["DATABASE_URL"]
    config = Configurator(settings=settings)
    config.include('pyramid_jinja2')
    config.include('.models')
    config.include('.routes')
    config.include('.security')
    config.scan()
    return config.make_wsgi_app()
Example #32
0
def main(global_config, **settings):
    settings.setdefault('jinja2.i18n.domain', 'CheesePrism')
    session_factory = UnencryptedCookieSessionFactoryConfig('cheeseprism')

    config = Configurator(root_factory=App, settings=settings,
                          session_factory=session_factory,
                          authentication_policy=\
                          BasicAuthenticationPolicy(BasicAuthenticationPolicy.noop_check))

    config.add_translation_dirs('locale/')
    config.include('pyramid_jinja2')
    config.add_renderer('.html', renderer_factory)

    config.add_static_view('static', 'static')
    config.scan('cheeseprism.views')
    config.scan('cheeseprism.index')
    config.set_request_factory(Request)
    config.add_route('package',
                     'package/{name}/{version}',
                     view='cheeseprism.views.from_pypi')
    settings['index_templates'] = EnvFactory.from_str(
        settings['cheeseprism.index_templates'])

    return config.make_wsgi_app()
Example #33
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    config = Configurator(settings=settings)
    config.configure_celery(global_config['__file__'])
    config.add_route('index', '/')
    config.add_route('add_task', '/add_task')
    config.add_route('delete_task', '/delete_task/{task_pk}')

    config.scan()

    return config.make_wsgi_app()
Example #34
0
from pyramid.view import view_config
from pyramid.config import Configurator
import logging

logging.basicConfig(level=logging.DEBUG)


def includeme(config):
    config.include('.kafka')
    config.add_route('app', '/')
    config.scan('.')


@view_config(route_name='app')
def app_route(request):
    request.response.status_int = 200
    return request.response


config = Configurator()
config.include(includeme)
application = config.make_wsgi_app()
Example #35
0
def main(global_config, **settings):
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)

    if 'timezone' in settings:
        temporal.default_timezone = pytz.timezone(settings['timezone'])

    authn_policy = AuthTktAuthenticationPolicy(settings['secret.authn_policy'],
                                               callback=permission_finder)
    authz_policy = ACLAuthorizationPolicy()
    session_factory = UnencryptedCookieSessionFactoryConfig(
        settings['secret.unencrypted_cookie'])

    config = Configurator(settings=settings,
                          root_factory='pyconca.security.RootFactory',
                          session_factory=session_factory)
    config.add_translation_dirs('pyconca:locale/')
    config.set_authentication_policy(authn_policy)
    config.set_authorization_policy(authz_policy)
    config.set_request_property(get_user, 'user', reify=True)
    config.add_static_view('static', 'static', cache_max_age=3600)

    _setup_routes(config)
    _add_api_resource(config, 'user')
    _add_resource(config, 'user')
    _add_api_resource(config, 'talk')
    _add_resource(config, 'talk')
    _add_api_resource(config, 'schedule_slot')

    config.scan()

    config.set_locale_negotiator("pyconca.locale.locale_negotiator")

    config.add_subscriber('pyconca.subscribers.add_localizer',
                          'pyramid.events.NewRequest')
    config.add_subscriber('pyconca.subscribers.add_renderer_globals',
                          'pyramid.events.BeforeRender')
    config.add_subscriber('pyconca.subscribers.add_template_globals',
                          'pyramid.events.BeforeRender')

    return config.make_wsgi_app()
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response


def hello_world(request):
    return Response("Hello %(name)s, I'm a pyramid web app!" %
                    request.matchdict)


config = Configurator()
config.add_route('hello', '/pyramid/{name}')
config.add_view(hello_world, route_name='hello')
app = config.make_wsgi_app()

# if __name__ == '__main__':
#     config = Configurator()
#     config.add_route('hello', '{name}')
#     config.add_view(hello_world, route_name='hello')
#     app = config.make_wsgi_app()
#     server = make_server('0.0.0.0', 8080, app)
#     server.serve_forever()
Example #37
0
File: zad.py Project: mkf/dtin-z8_2
    except ValueError as e:
        raise HTTPBadRequest(e)
    return {"id": fwi.add(j)}


@view_config(route_name='recipe_api_one', renderer='json')
def recipe_api_one(request):
    id = request.matchdict['id']
    try:
        id = int(id)
    except ValueError as e:
        raise e
    return fwi[id]


config = Configurator()
config.add_route('recipe_new', '/recipe/new')
config.add_route('recipe_one', '/recipe/{id}')
config.add_route('recipe_api_new', '/recipe/api/new')
config.add_route('recipe_api_one', '/recipe/api/{id}')
config.include('pyramid_jinja2')
thisDirectory = os.path.dirname(os.path.realpath(__file__))
config.add_jinja2_search_path(thisDirectory)
config.commit()
jinja2_env = config.get_jinja2_environment()
jinja2_env.autoescape = False
config.scan()

app = config.make_wsgi_app()

if __name__ == '__main__':
Example #38
0
    def _makeOne(self, *arg, **kw):
        from pyramid.config import Configurator

        config = Configurator(*arg, **kw)
        return config
Example #39
0
def main(global_config, **settings):
    """This function returns a Pyramid WSGI application."""
    session_factory = SignedCookieSessionFactory("fishtest")
    config = Configurator(
        settings=settings,
        session_factory=session_factory,
        root_factory="fishtest.models.RootFactory",
    )
    config.include("pyramid_mako")
    config.set_default_csrf_options(require_csrf=False)

    def static_full_path(static_path):
        return Path(__file__).parent / f"static/{static_path}"

    def file_hash(file):
        return base64.b64encode(hashlib.sha384(
            file.read_bytes()).digest()).decode("utf8")

    # hash calculated by browser for sub-resource integrity checks:
    # https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity
    cache_busters = {
        f"{i}/{j.name}": file_hash(j)
        for i in ("css", "js") for j in static_full_path(i).glob(f"*.{i}")
    }

    rundb = RunDb()

    def add_rundb(event):
        event.request.rundb = rundb
        event.request.userdb = rundb.userdb
        event.request.actiondb = rundb.actiondb

    def add_renderer_globals(event):
        event["h"] = helpers
        event["cache_busters"] = cache_busters

    config.add_subscriber(add_rundb, NewRequest)
    config.add_subscriber(add_renderer_globals, BeforeRender)

    # Authentication
    def group_finder(username, request):
        return request.userdb.get_user_groups(username)

    secret = Path("~/fishtest.secret").expanduser().read_text()
    config.set_authentication_policy(
        AuthTktAuthenticationPolicy(secret,
                                    callback=group_finder,
                                    hashalg="sha512",
                                    http_only=True))
    config.set_authorization_policy(ACLAuthorizationPolicy())

    config.add_static_view("css", "static/css", cache_max_age=3600)
    config.add_static_view("js", "static/js", cache_max_age=3600)
    config.add_static_view("img", "static/img", cache_max_age=3600)

    config.add_route("home", "/")
    config.add_route("login", "/login")
    config.add_route("nn_upload", "/upload")
    config.add_route("logout", "/logout")
    config.add_route("signup", "/signup")
    config.add_route("user", "/user/{username}")
    config.add_route("profile", "/user")
    config.add_route("pending", "/pending")
    config.add_route("users", "/users")
    config.add_route("users_monthly", "/users/monthly")
    config.add_route("actions", "/actions")
    config.add_route("nns", "/nns")
    config.add_route("sprt_calc", "/sprt_calc")

    config.add_route("tests", "/tests")
    config.add_route("tests_finished", "/tests/finished")
    config.add_route("tests_run", "/tests/run")
    config.add_route("tests_view", "/tests/view/{id}")
    config.add_route("tests_user", "/tests/user/{username}")
    config.add_route("tests_stats", "/tests/stats/{id}")
    config.add_route("tests_live_elo", "/tests/live_elo/{id}")

    # Tests - actions
    config.add_route("tests_modify", "/tests/modify")
    config.add_route("tests_delete", "/tests/delete")
    config.add_route("tests_stop", "/tests/stop")
    config.add_route("tests_approve", "/tests/approve")
    config.add_route("tests_purge", "/tests/purge")

    # API
    config.add_route("api_request_task", "/api/request_task")
    config.add_route("api_update_task", "/api/update_task")
    config.add_route("api_failed_task", "/api/failed_task")
    config.add_route("api_stop_run", "/api/stop_run")
    config.add_route("api_request_version", "/api/request_version")
    config.add_route("api_beat", "/api/beat")
    config.add_route("api_request_spsa", "/api/request_spsa")
    config.add_route("api_active_runs", "/api/active_runs")
    config.add_route("api_get_run", "/api/get_run/{id}")
    config.add_route("api_get_task", "/api/get_task/{id}/{task_id}")
    config.add_route("api_upload_pgn", "/api/upload_pgn")
    config.add_route("api_download_pgn", "/api/pgn/{id}")
    config.add_route("api_download_pgn_100", "/api/pgn_100/{skip}")
    config.add_route("api_download_nn", "/api/nn/{id}")
    config.add_route("api_get_elo", "/api/get_elo/{id}")

    config.scan()
    return config.make_wsgi_app()
Example #40
0
def main(global_config, **settings):
    """pserve entry point"""
    session_factory = UnencryptedCookieSessionFactoryConfig('seekrit!')
    config = Configurator(settings=settings, session_factory=session_factory)
    config.include('pyramid_chameleon')
    deform.renderer.configure_zpt_renderer()
    config.add_static_view('static_deform', 'deform:static')
    config.add_route('mini_example', path='/')
    config.add_view(mini_example,
                    route_name="mini_example",
                    renderer="templates/mini.pt")
    return config.make_wsgi_app()
Example #41
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    config = Configurator(settings=settings)
    config.add_static_view('static', 'static', cache_max_age=3600)
    # todo
    config.add_route('home', '/')
    config.add_route('todo_index', '/todos')
    config.add_route('todo_create', '/todos/create')
    config.add_route('todo_update', '/todos/{id}/update')
    config.add_route('todo_delete', '/todos/{id}/update')
    config.scan()
    return config.make_wsgi_app()
Example #42
0
def main(global_config, **settings):
    settings.update(parse_settings(settings))
    config = Configurator(settings=settings)
    config.include("cornice")
    config.scan()
    config.add_renderer("xml", XMLRenderer)
    config.add_renderer("text", PlainTextRenderer)

    mongo = adapters.MongoDB(settings["kernel.app.mongodb.dsn"])
    Session = adapters.Session.partial(mongo)

    config.add_request_method(lambda request: services.get_handlers(Session),
                              "services",
                              reify=True)

    return config.make_wsgi_app()
Example #43
0
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import FileResponse
from pyramid.view import view_config
import my_barcode


@view_config(route_name='barcode', renderer='templates/barcode.jinja2')
def barcode(request):
    return []


@view_config(route_name='barcode', request_method='POST')
def post(request):
    nr_eans = my_barcode.upload_to_tuple(request.POST['file'].file)
    eans = my_barcode.create_eans(nr_eans)
    myzip = my_barcode.create_zipfile(eans)
    return FileResponse(myzip, content_type='application/zip')


if __name__ == '__main__':
    with Configurator() as config:
        config.include('pyramid_jinja2')
        config.add_route('barcode', '/')
        config.scan()
        app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 8080, app)
    server.serve_forever()
Example #44
0
def main(global_config, **settings):
    config = Configurator(root_factory=Root, settings=settings)
    config.scan()
    return config.make_wsgi_app()
Example #45
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    config = Configurator(settings=settings)
    config.include('pyramid_jinja2')
    config.include('.models')
    config.include('.routes')
    config.include('.security')
    config.add_static_view('deform_static', 'deform:static/')
    config.scan()
    return config.make_wsgi_app()
Example #46
0
        print(self.payload['pusher'])

        # do busy work...
        return "nothing to push payload"  # or simple {}

    @view_config(header="X-Github-Event:pull_request")
    def payload_pull_request(self):
        """This method is a continuation of PayloadView process, triggered if
        header HTTP-X-Github-Event type is Pull Request"""
        # {u'name': u'marioidival', u'email': u'*****@*****.**'}
        print(self.payload['pusher'])

        # do busy work...
        return "nothing to pull request payload"  # or simple {}

    @view_config(header="X-Github-Event:ping")
    def payload_push_ping(self):
        """This method is responding to a webhook ping"""
        return {'ping': True}


if __name__ == "__main__":
    config = Configurator()

    config.add_route("github_payload", "/github_payload/")
    config.scan()

    app = config.make_wsgi_app()
    server = make_server("0.0.0.0", 8888, app)
    server.serve_forever()
Example #47
0
def main(global_config, **settings):
    """ This function returns the Pyramid WSGI application.
    """
    config = Configurator(settings=settings)

    # http://docs.pylonsproject.org/projects/pyramid_exclog/dev/api.html#pyramid_exclog.includeme
    config.include('pyramid_exclog')
    # https://docs.pylonsproject.org/projects/pyramid_jinja2/dev/api.html#pyramid_jinja2.includeme
    config.include('pyramid_jinja2')
    config.get_jinja2_environment().filters.update({
        'date_format':
        import_string('tumblrproxy.lib.template_filter.date_format'),
        'tumblr_video':
        import_string('tumblrproxy.lib.tumblr_filter.video_embed')
    })

    # view handler
    config.include('tumblrproxy.controllers.blog')

    # jinja2 configuration
    config.add_jinja2_search_path("tumblrproxy:templates")

    # static content route
    config.add_static_view('static', 'static', cache_max_age=3600)

    return config.make_wsgi_app()
Example #48
0
def main(global_config, **settings):
    """This function returns a Pyramid WSGI application."""

    import mist.api.auth.middleware

    settings = {}

    configurator = Configurator(root_factory=Root, settings=settings)
    configurator.include('pyramid_chameleon')

    # Add custom adapter to the JSON renderer to avoid serialization errors
    json_renderer = JSON()

    def string_adapter(obj, request):
        return str(obj)

    json_renderer.add_adapter(object, string_adapter)
    configurator.add_renderer('json', json_renderer)

    # Add CSV renderer
    configurator.add_renderer('csv', 'mist.api.renderers.CSVRenderer')

    configurator.add_static_view('docs', path='../../../docs/build')

    # FIXME this should not be necessary
    social_auth_keys = {key: getattr(config, key, '')
                        for key in ('SOCIAL_AUTH_GOOGLE_OAUTH2_KEY',
                                    'SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET',
                                    'SOCIAL_AUTH_GITHUB_KEY',
                                    'SOCIAL_AUTH_GITHUB_SECRET',
                                    'SOCIAL_AUTH_INTRALOT_OAUTH2_KEY',
                                    'SOCIAL_AUTH_INTRALOT_OAUTH2_SECRET')}
    configurator.registry.settings.update(social_auth_keys)
    configurator.registry.settings.update(getattr(config,
                                                  'SOCIAL_AUTH_SETTINGS', {}))
    # /FIXME

    configurator.include(add_routes)
    configurator.scan(ignore=['mist.api.sock', 'mist.api.sockjs_mux'])

    for plugin in config.PLUGINS:
        log.info("Loading plugin mist.%s", plugin)
        configurator.include('mist.%s.add_routes' % plugin)
        ignore_modules = ['mist.%s.sock' % plugin, 'mist.%s.handler' % plugin]
        configurator.scan('mist.%s' % plugin, ignore=ignore_modules)

    app = mist.api.auth.middleware.AuthMiddleware(
        mist.api.auth.middleware.CsrfMiddleware(
            configurator.make_wsgi_app()
        )
    )

    for plugin in config.PLUGINS:
        try:
            module = importlib.import_module('mist.%s.middleware' % plugin)
            for middleware in module.CHAIN:
                app = middleware(app)
        except ImportError:
            pass

    return app
Example #49
0
from pyramid.config import Configurator
from pyramid.response import Response


def hello_world(request):
    return Response('Hello world!')


def goodbye_world(request):
    return Response('Goodbye world!')


config = Configurator()
config.add_view(hello_world)
config.add_view(goodbye_world, name='goodbye')
app = config.make_wsgi_app()
Example #50
0
def mkapp(*args, **kwargs):

    if config.devel_memory_profile:
        launch_memory_usage_server()

    with Configurator(debug_logger=log) as ctx:
        ctx.add_subscriber(add_cors_headers_response_callback, NewRequest)

        if config.aliases is None:
            config.aliases = dict()

        if config.modules is None:
            config.modules = []

        ctx.registry.config = config
        config.modules.append('pyff.builtins')
        for mn in config.modules:
            importlib.import_module(mn)

        pipeline = args
        if not len(pipeline) > 0:
            pipeline = [config.pipeline]

        ctx.registry.scheduler = make_default_scheduler()
        ctx.registry.pipeline = pipeline
        ctx.registry.plumbings = [plumbing(v) for v in pipeline]
        ctx.registry.aliases = config.aliases
        ctx.registry.md = MDRepository()
        ctx.registry.md.store = make_store_instance(scheduler=ctx.registry.scheduler)
        log.debug(ctx.registry.md.store)

        ctx.add_route('robots', '/robots.txt')
        ctx.add_view(robots_handler, route_name='robots')

        ctx.add_route('webfinger', '/.well-known/webfinger', request_method='GET')
        ctx.add_view(webfinger_handler, route_name='webfinger')

        ctx.add_route('search', '/api/search', request_method='GET')
        ctx.add_view(search_handler, route_name='search')

        ctx.add_route('status', '/api/status', request_method='GET')
        ctx.add_view(status_handler, route_name='status')

        ctx.add_route('resources', '/api/resources', request_method='GET')
        ctx.add_view(resources_handler, route_name='resources')

        ctx.add_route('pipeline', '/api/pipeline', request_method='GET')
        ctx.add_view(pipeline_handler, route_name='pipeline')

        ctx.add_route('call', '/api/call/{entry}', request_method=['POST', 'PUT'])
        ctx.add_view(process_handler, route_name='call')

        ctx.add_route('request', '/*path', request_method='GET')
        ctx.add_view(process_handler, route_name='request')

        start = datetime.utcnow()+timedelta(seconds=1)
        log.debug(start)
        if config.update_frequency > 0:
            ctx.registry.scheduler.add_job(call,
                                           'interval',
                                           id="call/update",
                                           args=['update'],
                                           start_date=start,
                                           seconds=config.update_frequency,
                                           max_instances=1)

        ctx.registry.scheduler.start()
        return ctx.make_wsgi_app()
Example #51
0
 def test_unit__bind__err__not_implemented(self):
     controller = Controller()
     configurator = Configurator()
     with pytest.raises(NotImplementedError):
         controller.bind(configurator)
Example #52
0
    def bind(self, configurator: Configurator) -> None:
        """
        Create all routes and views using
        pyramid configurator for this controller
        """

        # Workspaces
        configurator.add_route("workspaces",
                               "/workspaces",
                               request_method="GET")
        configurator.add_view(self.workspaces, route_name="workspaces")
        # Workspace
        configurator.add_route("workspace",
                               "/workspaces/{workspace_id}",
                               request_method="GET")
        configurator.add_view(self.workspace, route_name="workspace")
        # Workspace space
        configurator.add_route("workspace_disk_space",
                               "/workspaces/{workspace_id}/disk_space",
                               request_method="GET")
        configurator.add_view(self.workspace_disk_space,
                              route_name="workspace_disk_space")
        # Create workspace
        configurator.add_route("create_workspace",
                               "/workspaces",
                               request_method="POST")
        configurator.add_view(self.create_workspace,
                              route_name="create_workspace")
        # Delete/Undelete workpace
        configurator.add_route("delete_workspace",
                               "/workspaces/{workspace_id}/trashed",
                               request_method="PUT")
        configurator.add_view(self.delete_workspace,
                              route_name="delete_workspace")
        configurator.add_route("undelete_workspace",
                               "/workspaces/{workspace_id}/trashed/restore",
                               request_method="PUT")
        configurator.add_view(self.undelete_workspace,
                              route_name="undelete_workspace")
        # Update Workspace
        configurator.add_route("update_workspace",
                               "/workspaces/{workspace_id}",
                               request_method="PUT")
        configurator.add_view(self.update_workspace,
                              route_name="update_workspace")
        # Workspace Members (Roles)
        configurator.add_route("workspace_members",
                               "/workspaces/{workspace_id}/members",
                               request_method="GET")
        configurator.add_view(self.workspaces_members,
                              route_name="workspace_members")
        # Workspace Members (Role) Individual
        configurator.add_route(
            "workspace_member_role",
            "/workspaces/{workspace_id}/members/{user_id}",
            request_method="GET",
        )
        configurator.add_view(self.workspaces_member_role,
                              route_name="workspace_member_role")
        # Update Workspace Members roles
        configurator.add_route(
            "update_workspace_member",
            "/workspaces/{workspace_id}/members/{user_id}",
            request_method="PUT",
        )
        configurator.add_view(self.update_workspaces_members_role,
                              route_name="update_workspace_member")
        # Create Workspace Members roles
        configurator.add_route("create_workspace_member",
                               "/workspaces/{workspace_id}/members",
                               request_method="POST")
        configurator.add_view(self.create_workspaces_members_role,
                              route_name="create_workspace_member")
        # Delete Workspace Members roles
        configurator.add_route(
            "delete_workspace_member",
            "/workspaces/{workspace_id}/members/{user_id}",
            request_method="DELETE",
        )
        configurator.add_view(self.delete_workspaces_members_role,
                              route_name="delete_workspace_member")
        # Workspace Content
        configurator.add_route("workspace_content",
                               "/workspaces/{workspace_id}/contents",
                               request_method="GET")
        configurator.add_view(self.workspace_content,
                              route_name="workspace_content")
        # Create Generic Content
        configurator.add_route("create_generic_content",
                               "/workspaces/{workspace_id}/contents",
                               request_method="POST")
        configurator.add_view(self.create_generic_empty_content,
                              route_name="create_generic_content")
        # Get Content
        configurator.add_route("get_content",
                               "/contents/{content_id}",
                               request_method="GET")
        configurator.add_view(self.get_content, route_name="get_content")
        # Get Content From workspace
        configurator.add_route(
            "get_content_from_workspace",
            "/workspaces/{workspace_id}/contents/{content_id}",
            request_method="GET",
        )
        configurator.add_view(self.get_content_from_workspace,
                              route_name="get_content_from_workspace")
        # Move Content
        configurator.add_route(
            "move_content",
            "/workspaces/{workspace_id}/contents/{content_id}/move",
            request_method="PUT",
        )
        configurator.add_view(self.move_content, route_name="move_content")
        # Delete/Undelete Content
        configurator.add_route(
            "delete_content",
            "/workspaces/{workspace_id}/contents/{content_id}/trashed",
            request_method="PUT",
        )
        configurator.add_view(self.delete_content, route_name="delete_content")
        configurator.add_route(
            "undelete_content",
            "/workspaces/{workspace_id}/contents/{content_id}/trashed/restore",
            request_method="PUT",
        )
        configurator.add_view(self.undelete_content,
                              route_name="undelete_content")
        # # Archive/Unarchive Content
        configurator.add_route(
            "archive_content",
            "/workspaces/{workspace_id}/contents/{content_id}/archived",
            request_method="PUT",
        )
        configurator.add_view(self.archive_content,
                              route_name="archive_content")
        configurator.add_route(
            "unarchive_content",
            "/workspaces/{workspace_id}/contents/{content_id}/archived/restore",
            request_method="PUT",
        )
        configurator.add_view(self.unarchive_content,
                              route_name="unarchive_content")

        # Subscriptions
        configurator.add_route(
            "workspace_subscriptions",
            "/workspaces/{workspace_id}/subscriptions",
            request_method="GET",
        )
        configurator.add_view(self.workspace_subscriptions,
                              route_name="workspace_subscriptions")
        configurator.add_route(
            "accept_subscription",
            "/workspaces/{workspace_id}/subscriptions/{user_id}/accept",
            request_method="PUT",
        )
        configurator.add_view(self.accept_subscription,
                              route_name="accept_subscription")

        configurator.add_route(
            "reject_subscription",
            "/workspaces/{workspace_id}/subscriptions/{user_id}/reject",
            request_method="PUT",
        )
        configurator.add_view(self.reject_subscription,
                              route_name="reject_subscription")
        # Content path
        configurator.add_route(
            "get_content_path",
            "/workspaces/{workspace_id}/contents/{content_id}/path",
            request_method="GET",
        )
        configurator.add_view(self.get_content_path,
                              route_name="get_content_path")
Example #53
0
def main(global_config, **settings):
    config = Configurator(settings=settings)
    init(config)
    return config.make_wsgi_app()
Example #54
0
def main(global_config, config=None, **settings):
    if not config:
        config = Configurator(settings=settings, root_factory=RouteFactory)

    # Force project name, since it determines settings prefix.
    config.add_settings({'kinto.project_name': 'kinto'})

    kinto.core.initialize(config,
                          version=__version__,
                          default_settings=DEFAULT_SETTINGS)

    settings = config.get_settings()

    # Expose capability
    schema_enabled = asbool(
        settings['experimental_collection_schema_validation'])
    if schema_enabled:
        config.add_api_capability(
            "schema",
            description="Validates collection records with JSON schemas.",
            url="https://kinto.readthedocs.io/en/latest/api/1.x/"
            "collections.html#collection-json-schema")

    # Scan Kinto views.
    kwargs = {}

    flush_enabled = asbool(settings['flush_endpoint_enabled'])
    if flush_enabled:
        config.add_api_capability(
            "flush_endpoint",
            description="The __flush__ endpoint can be used to remove all "
            "data from all backends.",
            url="https://kinto.readthedocs.io/en/latest/configuration/"
            "settings.html#activating-the-flush-endpoint")
    else:
        kwargs['ignore'] = ['kinto.views.flush']

    # Permissions endpoint enabled if permission backend is setup.
    permissions_endpoint_enabled = (asbool(
        settings['experimental_permissions_endpoint'])
                                    and hasattr(config.registry, 'permission'))
    if permissions_endpoint_enabled:
        config.add_api_capability(
            "permissions_endpoint",
            description="The permissions endpoint can be used to list all "
            "user objects permissions.",
            url="https://kinto.readthedocs.io/en/latest/configuration/"
            "settings.html#activating-the-permissions-endpoint")
    else:
        kwargs.setdefault('ignore', []).append('kinto.views.permissions')

    config.scan("kinto.views", **kwargs)

    app = config.make_wsgi_app()

    # Install middleware (no-op if disabled)
    return kinto.core.install_middlewares(app, settings)
Example #55
0
def app():
    from webtest import TestApp

    settings = dict()
    settings['error.err_response'] = exception.json_error_response
    settings['error.exc_response'] = exception.json_error_response

    config = Configurator(settings=settings)
    config.include(exception)

    def view_error(request):
        raise ErrorTest()

    config.add_route('error', '/error')
    config.add_view(view_error, route_name='error')

    def view_exception(request):
        raise ExceptionTest()

    config.add_route('exception', '/exception')
    config.add_view(view_exception, route_name='exception')

    def view_json(request):
        request.json
        request.json_body
        return Response('OK', status_code=200)

    config.add_route('json', '/json')
    config.add_view(view_json, route_name='json')

    yield TestApp(config.make_wsgi_app())
Example #56
0
def main(global_config, **settings):
    config = Configurator(settings=settings)

    db_url = urlparse(settings['mongo_uri'])
    config.registry.db = MongoClient(
        host=db_url.hostname,
        port=db_url.port,
    )

    def add_db(request):
        db = config.registry.db[db_url.path[1:]]
        if db_url.username and db_url.password:
            db.authenticate(db_url.username, db_url.password)
        return db

    config.add_request_method(add_db, 'db', reify=True)

    config.include('pyramid_chameleon')
    config.add_route('home', '/')
    config.add_route('add', '/add')
    config.add_route('rank', '/rank')
    config.add_static_view(name='static', path='PyTube:static')
    config.scan('.views')
    return config.make_wsgi_app()
Example #57
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    init_model()

    session_factory = session_factory_from_settings(settings)
    if 'localization' not in settings:
        settings['localization'] = 'id_ID.UTF-8'
    locale.setlocale(locale.LC_ALL, settings['localization'])
    if 'timezone' not in settings:
        settings['timezone'] = DefaultTimeZone
    config = Configurator(settings=settings,
                          root_factory='inventory.models.RootFactory',
                          session_factory=session_factory)
    config.include('pyramid_beaker')
    config.include('pyramid_chameleon')

    authn_policy = AuthTktAuthenticationPolicy('sosecret',
                                               callback=group_finder,
                                               hashalg='sha512')
    authz_policy = ACLAuthorizationPolicy()
    config.set_authentication_policy(authn_policy)
    config.set_authorization_policy(authz_policy)
    config.add_request_method(get_user, 'user', reify=True)
    config.add_request_method(get_title, 'title', reify=True)
    config.add_notfound_view(RemoveSlashNotFoundViewFactory())

    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_static_view('deform_static', 'deform:static')
    config.add_static_view('files', settings['static_files'])

    routes = DBSession.query(Route.kode, Route.path, Route.nama).all()
    for route in routes:
        config.add_route(route.kode, route.path)
        if route.nama:
            titles[route.kode] = ' - '.join([main_title, route.nama])

    config.scan()

    app = config.make_wsgi_app()
    from paste.translogger import TransLogger
    app = TransLogger(app, setup_console_handler=False)
    return app
Example #58
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine

    authn_policy = AuthTktAuthenticationPolicy('auth.secret', callback=groupfinder)
    authz_policy = ACLAuthorizationPolicy()

    config = Configurator(settings=settings,
        authentication_policy=authn_policy,
        authorization_policy=authz_policy,
        root_factory=RootFactory,
    )
    config.include('pyramid_mako')

    config.add_route('home', '/')
    config.add_route('login', '/login')
    config.add_route('logout', '/logout')

    config.add_route('users', '/users', factory=UserFactory)
    config.add_route('user', '/user/{login}', factory=UserFactory,
                     traverse='/{login}')

    config.add_route('pages', '/pages', factory=PageFactory)
    config.add_route('create_page', '/create_page', factory=PageFactory)
    config.add_route('page', '/page/{title}', factory=PageFactory,
                     traverse='/{title}')
    config.add_route('edit_page', '/page/{title}/edit', factory=PageFactory,
                     traverse='/{title}')
    config.scan()

    return config.make_wsgi_app()
Example #59
0
def main(global_config, **settings):
    """This function returns a Pyramid WSGI application."""
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    config = Configurator(settings=settings)
    authentication_policy = AuthTktAuthenticationPolicy(
        secret=settings['auth.secret'],
        ##callback=group_finder,
        hashalg=settings.get('auth.hash-algorithm', 'sha512'),
    )
    config.set_authentication_policy(authentication_policy)
    authorization_policy = ACLAuthorizationPolicy()
    config.set_authorization_policy(authorization_policy)

    # Route registration
    config.include(register_bbb)
    config.include(register_api, route_prefix='/api')
    config.include(set_up_velruse)
    config.include(set_up_service_exchange)
    config.include(register_www_iface)
    config.scan()
    return config.make_wsgi_app()
Example #60
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    config = Configurator(settings=settings)
    config.include('pyramid_chameleon')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.add_route('ups_view', '/{ups}')
    config.add_view('webnut.views.notfound',
                    renderer='webnut:templates/404.pt',
                    context='pyramid.exceptions.NotFound')
    config.scan()
    return config.make_wsgi_app()