def boostrap_from_config(config_file_name):
    """
    just a small wrapper that does the same as uwsgi with the ``*.ini`` file, via ``setup.py``
    take the given filename, bootstrap an app and configure lgging for it

    see http://stackoverflow.com/a/19058365

    :param config_file_name:
    :return:
    """
    assert config_file_name is not None
    if not os.path.exists(config_file_name):
        raise RuntimeError('file does not exist: %s' % config_file_name)
    config_file_name = os.path.realpath(config_file_name)

    # monkeypatching psycopg2 compatibility
    # https://github.com/chtd/psycopg2cffi
    from psycopg2cffi import compat
    compat.register()

    # dont use paste, but pyramid to also configure logging http://stackoverflow.com/a/19058365
    # from paste.deploy import loadapp
    # loadapp("config:%s" % config_file)
    pyramid.paster.setup_logging(config_file_name)
    app = pyramid.paster.get_app(config_file_name)

    log.debug('used configfile: %s', config_file_name)
    return app

def hack_psycopg2cffi():  # pragma: nocover
    try:
        from psycopg2cffi import compat
    except ImportError:
        pass
    else:
        compat.register()
    finally:
        import psycopg2
    return

def make_wsgi_application(global_config, **local_conf):
    """
    generic function to create a wsgi application out of a given paster config

    :param global_config:
    :param local_conf:
    :return:
    """

    # monkeypatching psycopg2 compatibility
    # https://github.com/chtd/psycopg2cffi
    from psycopg2cffi import compat
    compat.register()

    # Do something before importing Django and your settings have been applied.
    if global_config['__file__'] not in __apps_by_ini_configuration__:
        log.debug('create django wsgi app from ini-file %s...', global_config['__file__'])
        app = get_configured_django_wsgi_app(global_config, **local_conf)

        # Do something right after your application has been set up (e.g., add WSGI middleware).
        # http://rhodesmill.org/brandon/2011/wsgi-under-cherrypy/

        # non-standard customization: we want to be able to switch a function via ini-configuration
        from django.conf import settings as django_settings

        # TODO amb: tiny hack: cookie-domain must be a string. dunno where this becomes a unicode
        django_settings.SESSION_COOKIE_DOMAIN = str(django_settings.SESSION_COOKIE_DOMAIN)

        log.debug('FIXTURE_DIRS:    %s', getattr(django_settings, 'FIXTURE_DIRS', None))

        debug_flag = global_config['debug'] == 'true' or False
        if debug_flag:
            log.debug('add `TransLogger` to see all requests')
            app = TransLogger(app)
        __apps_by_ini_configuration__[global_config['__file__']] = app
    else:
        log.warn('reuse django wsgi app from ini-file %s to avoid ``django.conf`` collisions',
                 global_config['__file__'])
    return __apps_by_ini_configuration__[global_config['__file__']]

def greenify():
    """Patch threading and psycopg2 modules for green threads."""
    # don't greenify twice.
    if _GREEN:
        return
    _GREEN[True] = True

    from gevent.monkey import patch_all, saved
    if ('threading' in sys.modules) and ('threading' not in saved):
        raise Exception('threading module loaded before patching!')
    patch_all()

    from psycogreen.gevent import patch_psycopg
    patch_psycopg()

    try:
        # Use psycopg2 by default
        import psycopg2
        del psycopg2
    except ImportError:
        # Fallback to psycopg2cffi if required (eg: pypy)
        from psycopg2cffi import compat
        compat.register()

def init_sa(config, **connect_kwargs):
    settings = config.registry.settings

    pc_name = settings.pop('sqlalchemy.poolclass', '')
    if pc_name:
        resolver = DottedNameResolver()
        pool_class = resolver.maybe_resolve(pc_name)
        settings['sqlalchemy.poolclass'] = pool_class

    # http://stackoverflow.com/a/15691283
    engine = engine_from_config(settings, 'sqlalchemy.',
                                connect_args=connect_kwargs)

    db_session = get_db_session(None, settings)
    db_session.configure(bind=engine)
    model_paths = config.registry.setdefault('bowab.models', set())
    for emp in model_paths:
        config.scan(emp)

    if '__pypy__' in sys.builtin_module_names:
        from psycopg2cffi import compat
        compat.register()

    return db_session

# Flask-Restless is distributed under both the GNU Affero General Public
# License version 3 and under the 3-clause BSD license. For more
# information, see LICENSE.AGPL and LICENSE.BSD.
"""Unit tests for filtering resources in client requests."""
from datetime import date
from datetime import datetime
from datetime import time
from operator import itemgetter

# This import is unused but is required for testing on PyPy. CPython can
# use psycopg2, but PyPy can only use psycopg2cffi.
try:
    import psycopg2
except ImportError:
    from psycopg2cffi import compat
    compat.register()
from sqlalchemy import Column
from sqlalchemy import Date
from sqlalchemy import DateTime
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import Time
from sqlalchemy import Unicode
from sqlalchemy.dialects.postgresql import INET
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.orm import backref
from sqlalchemy.orm import relationship
from testing.postgresql import PostgresqlFactory as PGFactory

from .helpers import check_sole_error
from .helpers import dumps

def app_factory():
    """Factory function for the WSGI application object.

    Reads config, initializes Flask extensions that are part of the core,
    loads pg-config drivers and extensions, and configures core views.
    """
    # Use psycopg2cffi if PYPY
    if _compat.PYPY:  # pragma: no cover
        pg2cfficompat.register()

    # Flask application
    app = flask.Flask('pg-discuss')
    app.root_path = os.path.abspath(os.path.dirname(__file__))

    # Load default config values from pg_discuss.config module
    app.config.from_object(config)

    # Load custom config from user-defined PG_DISCUSS_SETTINGS_FILE
    custom_settings = os.environ.get('PG_DISCUSS_SETTINGS_FILE',
                                     '/opt/pg-discuss/local_settings.py')
    if custom_settings and os.path.isfile(custom_settings):
        app.config.from_pyfile(custom_settings)

    # Set the recursion limit
    sys.setrecursionlimit(app.config['PYTHON_RECURSION_LIMIT'])

    # Flask-SQLAlchemy
    db.init_app(app)

    # Flask-Migrate
    app.migrate = flask_migrate.Migrate(app, db)

    # Flask-Script
    app.script_manager = flask_script.Manager(app)
    app.script_manager.add_command('db', flask_migrate.MigrateCommand)
    app.script_manager.add_command('createadminuser',
                                   auth_forms.CreateAdminUser)

    # Flask-Login, for Admin users.
    app.admin_login_manager = flask_login.LoginManager(app)
    # Set up callback to load user objects`
    app.admin_login_manager.user_loader(
        lambda user_id: db.session.query(models.AdminUser).get(user_id))

    # Use stevedore to load drivers/extensions.
    # Discover all drivers/extensions, but do not load any.
    # Used for logging found extensions.
    app.ext_mgr_all = stevedore.ExtensionManager(namespace='pg_discuss.ext')

    # Load configured IdentityPolicy driver
    app.identity_policy_loader = stevedore.DriverManager(
        namespace='pg_discuss.ext',
        name=app.config['DRIVER_IDENTITY_POLICY'],
    )
    # Initialize IdentityPolicyManager with configured IdentityManager
    app.identity_policy_mgr = identity.IdentityPolicyManager(
        app,
        app.identity_policy_loader.driver,
    )

    # Load configured CommentRenderer driver
    app.comment_renderer_loader = stevedore.DriverManager(
        namespace='pg_discuss.ext',
        name=app.config['DRIVER_COMMENT_RENDERER'],
    )
    app.comment_renderer = app.comment_renderer_loader.driver(app)

    # Load configured JSONEncoder driver
    app.json_encoder_loader = stevedore.DriverManager(
        namespace='pg_discuss.ext',
        name=app.config['DRIVER_JSON_ENCODER'],
    )
    app.json_encoder = app.json_encoder_loader.driver

    # Exempt public read-only views from IdentityPolicy
    app.identity_policy_mgr.exempt(views.fetch)
    app.identity_policy_mgr.exempt(views.view)

    # Default routes. Other routes must be added through App extensions.
    # Default routes are set up before app extensions are loaded so extensions
    # can introspect/modify view functions.
    app.route('/threads/<thread_cid>/comments', methods=['GET'])(views.fetch)
    app.route('/threads/<thread_cid>/comments', methods=['POST'])(views.new)
    app.route('/comments/<int:comment_id>', methods=['GET'])(views.view)
    app.route('/comments/<int:comment_id>', methods=['PATCH'])(views.edit)
    app.route('/comments/<int:comment_id>', methods=['DELETE'])(views.delete)
    app.route('/login', methods=['GET', 'POST'])(views.admin_login)
    app.route('/logout', methods=['GET'])(views.admin_logout)

    # Load all extensions explicitly enabled via `ENABLE_EXT_*` parameters.
    app.ext_mgr = stevedore.NamedExtensionManager(
        namespace='pg_discuss.ext',
        names=config.get_enabled_extensions(app.config),
        name_order=True,
        invoke_on_load=True,
        invoke_kwds={'app': app},
        on_load_failure_callback=ext.fail_on_ext_load,
        propagate_map_exceptions=True,
    )
    # Create hook map
#.........这里部分代码省略.........

VERSION = '0.1.0.dev1'

try:
    from psycopg2cffi import compat as _compat
except ImportError:
    pass
else:
    _compat.register()

""":mod:`favien` --- Favien
~~~~~~~~~~~~~~~~~~~~~~~~~~~

"""
import platform


if platform.python_implementation() == 'PyPy':
    # Monkey patches for PyPy
    from psycopg2cffi.compat import register
    register()