def disqus_comments_view(context, request):
    settings = get_settings_util()
    available = settings.get('kotti_disqus-disqus_available_types', [])
    available += get_settings()['kotti_disqus.extra_types'].split()

    resolver = DottedNameResolver(None)
    types = tuple(resolver.resolve(typ) for typ in available)

    if not isinstance(context, types):
        raise PredicateMismatch()

    api = template_api(context, request)
    disqus_url = ''
    disqus_shortname = settings['kotti_disqus-disqus_shortname']

    base_url = settings['kotti_disqus-disqus_base_url'].strip('/')

    if base_url:
        disqus_url = base_url + api.url(context)[len(request.application_url):]
    else:
        disqus_url = api.url(context)

    return {
        'disqus_shortname': disqus_shortname,
        'disqus_url': disqus_url,
    }

    def check_password(cls, **kwargs):
        if kwargs.has_key('id'):
            user = cls.get_by_id(kwargs['id'])
        if kwargs.has_key('login'):
            user = cls.get_by_login(kwargs['login'])

        request = get_current_request()
        use_sha256 = asbool(request.registry.settings.get('apex.use_sha256'))

        if not user:
            return False

        try:
            if use_sha256:
                pw = kwargs['password']
                if CRYPTPasswordManager(SHA256CRYPT).check(user.password, pw):
                    return True
            else:
                pw = kwargs['password'] + user.salt
                if BCRYPTPasswordManager().check(user.password, pw):
                    return True
        except TypeError:
            pass

        fallback_auth = request.registry.settings.get('apex.fallback_auth')
        if fallback_auth:
            resolver = DottedNameResolver(fallback_auth.split('.', 1)[0])
            fallback = resolver.resolve(fallback_auth)
            pw = kwargs['password']
            return fallback().check(DBSession, request, user, pw)

        return False

def get_storage_factory(settings, prefix='filestore'):
    """Uses a Pyramid deployment settings dictionary to construct and return
    an instance of a :class:`FileStorage` subclass.

    The `prefix` will be used to extract storage configuration.  The package to
    use is determined by the `$prefix` config setting, and any setting named
    `$prefix.$key` will be passed to the subclass constructor as `$key`.

    The `$prefix` config setting may be either the full dotted python name of a
    data manager class, or the name of one of the modules in the
    floof.model.filestore namespace, currently `local` or `mogilefs`.
    """
    # Pull prefix.key out of the config object
    kwargs = {}
    plen = len(prefix)
    for key, val in settings.iteritems():
        if key[0:plen] == prefix and len(key) > plen:
            kwargs[ key[plen+1:] ] = val

    # Resolve the data manager
    resolver = DottedNameResolver(None)
    manager = settings[prefix]
    name = 'floof.model.filestore.' + manager + '.FileStorage'
    try:
        storage = resolver.resolve(name)
    except ImportError:
        storage = resolver.resolve(manager)

    def storage_factory():
        """Returns an instance of the chosen data manager for attachement to a
        request object and use over the life of a single request.  The instance
        must be manually joined to a Zope-style transaction."""
        return storage(transaction.manager, **kwargs)

    return storage_factory

def create_mailer(registry: Registry) -> IMailer:
    """Create a new mailer instance.

    """

    settings = registry.settings

    # Empty values are not handled gracefully, so mutate them here before passing forward to mailer
    if settings.get("mail.username", "x") == "":
        settings["mail.username"] = None

    if settings.get("mail.password", "x") == "":
        settings["mail.password"] = None

    mailer_class = settings.get("websauna.mailer", "")
    if mailer_class in ("mail", ""):
        # TODO: Make mailer_class explicit so we can dynamically load pyramid_mail.Mailer
        # Default
        from pyramid_mailer import mailer_factory_from_settings
        mailer = mailer_factory_from_settings(settings)
    else:
        # debug backend
        resolver = DottedNameResolver()
        mailer_cls = resolver.resolve(mailer_class)
        mailer = mailer_cls()

    return mailer

    def get_profile(self, request=None):
        """
        Returns AuthUser.profile object, creates record if it doesn't exist.

        .. code-block:: python

           from apex.models import AuthUser

           user = AuthUser.get_by_id(1)
           profile = user.get_profile(request)

        in **development.ini**

        .. code-block:: python

           apex.auth_profile = 
        """
        if not request:
            request = get_current_request()

        auth_profile = request.registry.settings.get('apex.auth_profile')
        if auth_profile:
            resolver = DottedNameResolver(auth_profile.split('.')[0])
            profile_cls = resolver.resolve(auth_profile)
            return get_or_create(DBSession, profile_cls, auth_id=self.id)

    def check_password(cls, **kwargs):
        if 'id' in kwargs:
            user = cls.get_by_id(kwargs['id'])
        if 'login' in kwargs:
            user = cls.get_by_login(kwargs['login'])

        if not user:
            return False
        try:
            if BCRYPTPasswordManager().check(user.password,
                                             '%s%s' % (kwargs['password'],
                                             user.salt)):
                return True
        except TypeError:
            pass

        request = get_current_request()
        fallback_auth = request.registry.settings.get('apex.fallback_auth')
        if fallback_auth:
            resolver = DottedNameResolver(fallback_auth.split('.', 1)[0])
            fallback = resolver.resolve(fallback_auth)
            return fallback().check(DBSession, request, user,
                       kwargs['password'])

        return False

def base_config(**settings):
    from pyramid.authorization import ACLAuthorizationPolicy
    resolver = DottedNameResolver()
    setup_defaults(settings)
    authn_policy = resolver.maybe_resolve(settings['arche.authn_factory'])(settings)
    authz_policy = ACLAuthorizationPolicy()
    return Configurator(root_factory = root_factory,
                        settings = settings,
                        authentication_policy = authn_policy,
                        authorization_policy = authz_policy,)

def renderer_factory(info):
    path = info.name
    registry = info.registry
    settings = info.settings
    lookup = registry.queryUtility(IMakoLookup)
    if lookup is None:
        reload_templates = settings.get('reload_templates', False)
        directories = settings.get('mako.directories', None)
        module_directory = settings.get('mako.module_directory', None)
        input_encoding = settings.get('mako.input_encoding', 'utf-8')
        error_handler = settings.get('mako.error_handler', None)
        default_filters = settings.get('mako.default_filters', 'h')
        imports = settings.get('mako.imports', None)
        strict_undefined = settings.get('mako.strict_undefined', 'false')
        preprocessor = settings.get('mako.preprocessor', None)
        if directories is None:
            raise ConfigurationError(
                'Mako template used without a ``mako.directories`` setting')
        if not is_nonstr_iter(directories):
            directories = list(filter(None, directories.splitlines()))
        directories = [ abspath_from_asset_spec(d) for d in directories ]
        if module_directory is not None:
            module_directory = abspath_from_asset_spec(module_directory)
        if error_handler is not None:
            dotted = DottedNameResolver(info.package)
            error_handler = dotted.maybe_resolve(error_handler)
        if default_filters is not None:
            if not is_nonstr_iter(default_filters):
                default_filters = list(filter(
                    None, default_filters.splitlines()))
        if imports is not None:
            if not is_nonstr_iter(imports):
                imports = list(filter(None, imports.splitlines()))
        strict_undefined = asbool(strict_undefined)
        if preprocessor is not None:
            dotted = DottedNameResolver(info.package)
            preprocessor = dotted.maybe_resolve(preprocessor)
            
        
        lookup = PkgResourceTemplateLookup(directories=directories,
                                           module_directory=module_directory,
                                           input_encoding=input_encoding,
                                           error_handler=error_handler,
                                           default_filters=default_filters,
                                           imports=imports,
                                           filesystem_checks=reload_templates,
                                           strict_undefined=strict_undefined,
                                           preprocessor=preprocessor)
        registry_lock.acquire()
        try:
            registry.registerUtility(lookup, IMakoLookup)
        finally:
            registry_lock.release()
            
    return MakoLookupTemplateRenderer(path, lookup)

def includeme(config):
    resolver = DottedNameResolver()

    service_name = config.registry.settings.get("sms.service")
    if not service_name:
        raise SMSConfigurationError("sms.service setting missing")

    service_cls = resolver.resolve(service_name)
    if not service_cls:
        raise SMSConfigurationError("Not a valid sms.service: {}".format(service_name))

    config.registry.registerAdapter(factory=service_cls, required=(IRequest,), provided=ISMSService)

 def pshell_file_config(self, filename):
     resolver = DottedNameResolver(None)
     self.loaded_objects = {}
     self.object_help = {}
     config = self.ConfigParser()
     config.read(filename)
     try:
         items = config.items('pshell')
     except ConfigParser.NoSectionError:
         return
     for k, v in items:
         self.loaded_objects[k] = resolver.maybe_resolve(v)
         self.object_help[k] = v

def includeme(config):
    """
    Pyramid entry point
    """
    settings = config.registry.settings

    config.add_tween('rollbar.contrib.pyramid.rollbar_tween_factory', under=EXCVIEW)

    # run patch_debugtoolbar, unless they disabled it
    if asbool(settings.get('rollbar.patch_debugtoolbar', True)):
        patch_debugtoolbar(settings)

    def hook(request, data):
        data['framework'] = 'pyramid'

        if request:
            request.environ['rollbar.uuid'] = data['uuid']

            if request.matched_route:
                data['context'] = request.matched_route.name

    rollbar.BASE_DATA_HOOK = hook

    kw = parse_settings(settings)

    access_token = kw.pop('access_token')
    environment = kw.pop('environment', 'production')

    if kw.get('scrub_fields'):
        kw['scrub_fields'] = set([str.strip(x) for x in kw.get('scrub_fields').split('\n') if x])

    if kw.get('exception_level_filters'):
        r = DottedNameResolver()
        exception_level_filters = []
        for line in kw.get('exception_level_filters').split('\n'):
            if line:
                dotted_path, level = line.split()

                try:
                    cls = r.resolve(dotted_path)
                    exception_level_filters.append((cls, level))
                except ImportError:
                    log.error('Could not import %r' % dotted_path)

        kw['exception_level_filters'] = exception_level_filters

    kw['enabled'] = asbool(kw.get('enabled', True))

    rollbar.init(access_token, environment, **kw)

def _find_methods(worker):
    cronjobsentry = worker.app.registry.settings.get('cronjobs')
    if cronjobsentry is None:
        raise ValueError("cronjobs must exist in application configuration if you want to run this. "
                         "It should point to methods that can be run by the crontick worker. "
                         "See voteit.core.scripts.crontick")

    resolver = DottedNameResolver(None)

    dotteds = [x.strip() for x in cronjobsentry.strip().splitlines()]
    methods = []
    for dotted in dotteds:
        try:
            methods.append(resolver.resolve(dotted))
        except ImportError, e:
            worker.logger.exception(e)

 def pshell_file_config(self, loader, defaults):
     settings = loader.get_settings('pshell', defaults)
     resolver = DottedNameResolver(None)
     self.loaded_objects = {}
     self.object_help = {}
     self.setup = None
     for k, v in settings.items():
         if k == 'setup':
             self.setup = v
         elif k == 'default_shell':
             self.preferred_shells = [x.lower() for x in aslist(v)]
         elif k in ('__file__', 'here'):
             continue
         else:
             self.loaded_objects[k] = resolver.maybe_resolve(v)
             self.object_help[k] = v

 def __init__(self,
              app_router: Router,
              rest_url: str='http://localhost',
              base_path: str='/',
              header: dict=None,
              user_path: str='',
              user_login: str='',
              user_password: str='',
              ):
     """Initialize self."""
     self.app_router = app_router
     """The adhocracy wsgi application"""
     self.app = TestApp(app_router)
     """:class:`webtest.TestApp`to send requests to the backend server."""
     self.rest_url = rest_url
     """backend server url to generate request urls."""
     self.base_path = base_path
     """path prefix to generate request urls."""
     self.header = header or {}
     """default header for requests, mostly for authentication.
        If not set, `user_login` and `user_password` is used to login,
        the new authentication header is stored in `header`.
     """
     if user_password and user_login and not header:
         token, user_path = self._get_token_and_user_path(user_login,
                                                          user_password)
         self.header = {UserTokenHeader: token}
     self.user_password = user_password
     """password for authenticated user."""
     self.user_login = user_login
     """login name for authenticated user."""
     self.user_path = user_path
     """path for authenticated user."""
     self._resolver = DottedNameResolver()

    def pshell_file_config(self, filename):
        config = self.ConfigParser()
        config.read(filename)
        try:
            items = config.items("pshell")
        except configparser.NoSectionError:
            return

        resolver = DottedNameResolver(None)
        self.loaded_objects = {}
        self.object_help = {}
        self.setup = None
        for k, v in items:
            if k == "setup":
                self.setup = v
            else:
                self.loaded_objects[k] = resolver.maybe_resolve(v)
                self.object_help[k] = v

 def __init__(self, app, rest_url: str = "http://localhost", base_path: str = "/", header: dict = None):
     """Initialize self."""
     self.app = TestApp(app)
     """:class:`webtest.TestApp`to send requests to the backend server."""
     self.rest_url = rest_url
     """backend server url to generate request urls."""
     self.base_path = base_path
     """path prefix to generate request urls."""
     self.header = header or {}
     """default header for requests, mostly for authentication."""
     self._resolver = DottedNameResolver()

    def pshell_file_config(self, filename):
        config = self.ConfigParser()
        config.optionxform = str
        config.read(filename)
        try:
            items = config.items('pshell')
        except configparser.NoSectionError:
            return

        resolver = DottedNameResolver(None)
        self.loaded_objects = {}
        self.object_help = {}
        self.setup = None
        for k, v in items:
            if k == 'setup':
                self.setup = v
            elif k == 'default_shell':
                self.preferred_shells = [x.lower() for x in aslist(v)]
            else:
                self.loaded_objects[k] = resolver.maybe_resolve(v)
                self.object_help[k] = v

    def check_password(cls, **kwargs):
        if kwargs.has_key("id"):
            user = cls.get_by_id(kwargs["id"])
        if kwargs.has_key("login"):
            user = cls.get_by_login(kwargs["login"])

        if not user:
            return False
        try:
            if BCRYPTPasswordManager().check(user.password, "%s%s" % (kwargs["password"], user.salt)):
                return True
        except TypeError:
            pass

        request = get_current_request()
        fallback_auth = request.registry.settings.get("apex.fallback_auth")
        if fallback_auth:
            resolver = DottedNameResolver(fallback_auth.split(".", 1)[0])
            fallback = resolver.resolve(fallback_auth)
            return fallback().check(DBSession, request, user, kwargs["password"])

        return False

    def __call__(self, info):
        p = re.compile(r"(?P<asset>[\w_.:/]+)" r"(?:\#(?P<defname>[\w_]+))?" r"(\.(?P<ext>.*))")
        asset, defname, ext = p.match(info.name).group("asset", "defname", "ext")
        path = "%s.%s" % (asset, ext)
        registry = info.registry
        settings = info.settings
        settings_prefix = self.settings_prefix

        if settings_prefix is None:
            settings_prefix = info.type + "."

        lookup = registry.queryUtility(IMakoLookup, name=settings_prefix)

        def sget(name, default=None):
            return settings.get(settings_prefix + name, default)

        if lookup is None:
            reload_templates = settings.get("pyramid.reload_templates", None)
            if reload_templates is None:
                reload_templates = settings.get("reload_templates", False)
            reload_templates = asbool(reload_templates)
            directories = sget("directories", [])
            module_directory = sget("module_directory", None)
            input_encoding = sget("input_encoding", "utf-8")
            error_handler = sget("error_handler", None)
            default_filters = sget("default_filters", "h")
            imports = sget("imports", None)
            strict_undefined = asbool(sget("strict_undefined", False))
            preprocessor = sget("preprocessor", None)
            if not is_nonstr_iter(directories):
                directories = list(filter(None, directories.splitlines()))
            directories = [abspath_from_asset_spec(d) for d in directories]
            if module_directory is not None:
                module_directory = abspath_from_asset_spec(module_directory)
            if error_handler is not None:
                dotted = DottedNameResolver(info.package)
                error_handler = dotted.maybe_resolve(error_handler)
            if default_filters is not None:
                if not is_nonstr_iter(default_filters):
                    default_filters = list(filter(None, default_filters.splitlines()))
            if imports is not None:
                if not is_nonstr_iter(imports):
                    imports = list(filter(None, imports.splitlines()))
            if preprocessor is not None:
                dotted = DottedNameResolver(info.package)
                preprocessor = dotted.maybe_resolve(preprocessor)

            lookup = PkgResourceTemplateLookup(
                directories=directories,
                module_directory=module_directory,
                input_encoding=input_encoding,
                error_handler=error_handler,
                default_filters=default_filters,
                imports=imports,
                filesystem_checks=reload_templates,
                strict_undefined=strict_undefined,
                preprocessor=preprocessor,
            )

            registry_lock.acquire()
            try:
                registry.registerUtility(lookup, IMakoLookup, name=settings_prefix)
            finally:
                registry_lock.release()

        return MakoLookupTemplateRenderer(path, defname, lookup)

    def run(self, shell=None):
        if self.args.list:
            return self.show_shells()
        if not self.args.config_uri:
            self.out('Requires a config file argument')
            return 2
        config_uri = self.args.config_uri
        config_vars = parse_vars(self.args.config_vars)
        loader = self.get_config_loader(config_uri)
        loader.setup_logging(config_vars)
        self.pshell_file_config(loader, config_vars)

        env = self.bootstrap(config_uri, options=config_vars)

        # remove the closer from the env
        self.closer = env.pop('closer')

        # setup help text for default environment
        env_help = dict(env)
        env_help['app'] = 'The WSGI application.'
        env_help['root'] = 'Root of the default resource tree.'
        env_help['registry'] = 'Active Pyramid registry.'
        env_help['request'] = 'Active request object.'
        env_help['root_factory'] = (
            'Default root factory used to create `root`.')

        # override use_script with command-line options
        if self.args.setup:
            self.setup = self.args.setup

        if self.setup:
            # store the env before muddling it with the script
            orig_env = env.copy()

            # call the setup callable
            resolver = DottedNameResolver(None)
            setup = resolver.maybe_resolve(self.setup)
            setup(env)

            # remove any objects from default help that were overidden
            for k, v in env.items():
                if k not in orig_env or env[k] != orig_env[k]:
                    if getattr(v, '__doc__', False):
                        env_help[k] = v.__doc__.replace("\n", " ")
                    else:
                        env_help[k] = v

        # load the pshell section of the ini file
        env.update(self.loaded_objects)

        # eliminate duplicates from env, allowing custom vars to override
        for k in self.loaded_objects:
            if k in env_help:
                del env_help[k]

        # generate help text
        help = ''
        if env_help:
            help += 'Environment:'
            for var in sorted(env_help.keys()):
                help += '\n  %-12s %s' % (var, env_help[var])

        if self.object_help:
            help += '\n\nCustom Variables:'
            for var in sorted(self.object_help.keys()):
                help += '\n  %-12s %s' % (var, self.object_help[var])

        if shell is None:
            try:
                shell = self.make_shell()
            except ValueError as e:
                self.out(str(e))
                self.closer()
                return 1

        if self.pystartup and os.path.isfile(self.pystartup):
            with open(self.pystartup, 'rb') as fp:
                exec_(fp.read().decode('utf-8'), env)
            if '__builtins__' in env:
                del env['__builtins__']

        try:
            shell(env, help)
        finally:
            self.closer()