Managing connection creation in Python?

Applications often need to connect to other services (a database, a cache, an API, etc). For sanity and DRY, we'd like to keep all of these connections in one module so the rest of our code base can share connections.

To reduce boilerplate, downstream usage should be simple:

# app/do_stuff.py
from .connections import AwesomeDBConnection

db = AwesomeDBConnection()

def get_stuff():
    return db.get('stuff')

And setting up the connection should also be simple:

# app/cli.py or some other main entry point
from .connections import AwesomeDBConnection

db = AwesomeDBConnection()
db.init(username='stuff admin')    # Or os.environ['DB_USER']

Web frameworks like Django and Flask do something like this, but it feels a bit clunky:

Connect to a Database in Flask, Which Approach is better? http://ift.tt/1poY194

One big issue with this is that we want a reference to the actual connection object instead of a proxy, because we want to retain tab-completion in iPython and other dev environments.

So what's the Right Way (tm) to do it? After a few iterations, here's my idea:

#app/connections.py
from awesome_database import DB as AwesomeDB
from horrible_database import DB as HorribleDB


class ConnectionMixin(object):
    __connection = None

    def __new__(cls):
        cls.__connection = cls.__connection or object.__new__(cls)
        return cls.__connection

    def __init__(self, real=False, **kwargs):
        if real:
            super().__init__(**kwargs)

    def init(self, **kwargs):
        kwargs['real'] = True
        self.__init__(**kwargs)


class AwesomeDBConnection(ConnectionMixin, AwesomeDB):
    pass


class HorribleDBConnection(ConnectionMixin, HorribleDB):
    pass

Room for improvement: Set initial __connection to a generic ConnectionProxy instead of None, which catches all attribute access and throws an exception.

I've done quite a bit of poking around here on SO and in various OSS projects and haven't seen anything like this. It feels pretty solid, though it does mean a bunch of modules will be instantiating connection objects as a side effect at import time. Will this blow up in my face? Are there any other negative consequences to this approach?