def init_data():
    from imports import (
            Widget,Article,Page,
            User,Setting,Type,
            Template,Tag,Role,
            Category,Block,Profile,
            ContactMessage)
    """Fish data for project"""
    if prompt_bool('Do you want to kill your db?'):
        if squ.database_exists(db.engine.url):
            squ.drop_database(db.engine.url)
    try:
        db.drop_all()
    except:
        pass
    try:
        squ.create_database(db.engine.url)
        db.create_all()
    except:
        pass

    user = User.query.filter(User.email=='[email protected]').first()
    if user is None:
       user = User(username='kyle', email='[email protected]', password='14wp88')
    user.save()

def create_ctfd(ctf_name="CTFd", name="admin", email="[email protected]", password="password", setup=True):
    app = create_app('CTFd.config.TestingConfig')

    url = make_url(app.config['SQLALCHEMY_DATABASE_URI'])
    if url.drivername == 'postgres':
        url.drivername = 'postgresql'

    if database_exists(url):
        drop_database(url)
        create_database(url)
        with app.app_context():
            app.db.create_all()

    if setup:
        with app.app_context():
            with app.test_client() as client:
                data = {}
                r = client.get('/setup')  # Populate session with nonce
                with client.session_transaction() as sess:
                    data = {
                        "ctf_name": ctf_name,
                        "name": name,
                        "email": email,
                        "password": password,
                        "nonce": sess.get('nonce')
                    }
                client.post('/setup', data=data)
    return app

def setup():
    print(app.config['SQLALCHEMY_DATABASE_URI'])
    engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'])
    if database_exists(engine.url):
        drop_database(engine.url)
    create_database(engine.url)
    engine.execute('create extension if not exists fuzzystrmatch')

    def makeDbEngine(self):
        '''
        function to establish engine with PostgreSQl database
        so that additional tables can be made 
        '''
        try:
            ## connect to Postgres
            dbname = self.getDbName()
            username = self.getUserName()
            print dbname
            print username
            
            ## create and set 
            engine = create_engine('postgres://%[email protected]/%s'%(username, dbname))
            self.setDbEngine(engine)

            ## test if it exists
            db_exist = database_exists(engine.url)
            if not db_exist:
                create_database(engine.url)
            db_exist = database_exists(engine.url)
            self.setDbExist(db_exist)
            return 0
        except:
            return 1

def add_db():  # pragma: no cover
    db_url = config['service']['db_uri']
    global engine
    engine = create_engine(db_url)

    if database_exists(engine.url):
        print('!!! DATABASE ALREADY EXISTS !!!')
        return False

    print()
    print('!!! DATABASE NOT DETECTED !!!')
    print()

    try:
        confirm = input('Create database designated in the config file? [Y/n]') or 'Y'
    except KeyboardInterrupt:
        confirm = ''
        print()

    if confirm.strip() != 'Y':
        print('Not createing DB. Exiting.')
        return False

    create_database(engine.url)
    return True

    def init_db(self):
        """
        Initializes the database connection based on the configuration parameters
        """
        db_type = self.config['db_type']
        db_name = self.config['db_name']
        if db_type == 'sqlite':
            # we can ignore host, username, password, etc
            sql_lite_db_path = os.path.join(os.path.split(CONFIG)[0], db_name)
            self.db_connection_string = 'sqlite:///{}'.format(sql_lite_db_path)
        else:
            username = self.config['username']
            password = self.config['password']
            host_string = self.config['host_string']
            self.db_connection_string = '{}://{}:{}@{}/{}'.format(db_type, username, password, host_string, db_name)

        self.db_engine = create_engine(self.db_connection_string)
        # If db not present AND type is not SQLite, create the DB
        if not self.config['db_type'] == 'sqlite':
            if not database_exists(self.db_engine.url):
                create_database(self.db_engine.url)
        Base.metadata.bind = self.db_engine
        Base.metadata.create_all()
        # Bind the global Session to our DB engine
        global Session
        Session.configure(bind=self.db_engine)

def create_postgres_db():
    dbname = 'beer_db_2'
    username = 'postgres'
    mypassword = 'simple'
    
    ## Here, we're using postgres, but sqlalchemy can connect to other things too.
    engine = create_engine('postgres://%s:%[email protected]/%s'%(username,mypassword,dbname))
    print "Connecting to",engine.url
    
    if not database_exists(engine.url):
        create_database(engine.url)
    print "Does database exist?",(database_exists(engine.url))
    
    # load a database from CSV
    brewery_data = pd.DataFrame.from_csv('clean_data_csv/brewery_information_rescrape.csv')
    
    ## insert data into database from Python (proof of concept - this won't be useful for big data, of course)
    ## df is any pandas dataframe 
    brewery_data.to_sql('breweries', engine, if_exists='replace')

    #dbname = 'beer_review_db'
    # load a database from CSV
    beer_data = pd.DataFrame.from_csv('clean_data_csv/beer_review_information_rescrape.csv')
    #engine_2 = create_engine('postgres://%s:%[email protected]/%s'%(username,mypassword,dbname))
    #print "connecting to",engine.url
    
    #if not database_exists(engine_2.url):
    #    create_database(engine_2.url)
        
    #print "Does database exist?",(database_exists(engine_2.url))
    beer_data.to_sql('reviews',engine,if_exists='replace')
    print "database",dbname,"has been created"
    return

def app(request):
    """The Flask API (scope = Session)."""
    config.DB_NAME = DB_NAME
    DATABASE_URI = config.DATABASE_URI.format(**config.__dict__)

    if not database_exists(DATABASE_URI):
        create_database(DATABASE_URI)

    print "Test Database: %s" % DATABASE_URI

    # Config the app
    _app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URI
    _app.config["SQLALCHEMY_ECHO"] = True # Toggle SQL Alchemy output
    _app.config["DEBUG"] = True
    _app.config["TESTING"] = True

    # Establish an application context before running the tests.
    ctx = _app.app_context()
    ctx.push()

    # Initialize a null cache
    cache.config = {}
    cache.init_app(_app)

    def teardown():
        ctx.pop()

    request.addfinalizer(teardown)
    return _app

def create_findmyride_database(database_name):
    engine = create_engine('postgresql://%s:%[email protected]/%s'%('dianeivy', password, database_name))
    print(engine.url)

    if not database_exists(engine.url):
        create_database(engine.url)
    print(database_exists(engine.url))
    return engine

def create_db_test():
    create_database(url_db)
    session = sessionmaker()
    engine = create_engine(url_db)
    session.configure(bind=engine)
    Base.metadata.create_all(engine)

    return engine

def create_db(app):
    from project.core.db import db
    from sqlalchemy_utils import database_exists, create_database
    if not database_exists(db.engine.url):
        print '====> Create database'
        create_database(db.engine.url)
    else:
        print '====> database exist'

    def start_fixture(self):
        """Create necessary temp files and do the config dance."""

        global CONF

        data_tmp_dir = tempfile.mkdtemp(prefix='gnocchi')
        coordination_dir = os.path.join(data_tmp_dir, 'tooz')
        os.mkdir(coordination_dir)
        coordination_url = 'file://%s' % coordination_dir

        conf = service.prepare_service([])

        CONF = self.conf = conf
        self.tmp_dir = data_tmp_dir

        # Use the indexer set in the conf, unless we have set an
        # override via the environment.
        if 'GNOCCHI_TEST_INDEXER_URL' in os.environ:
            conf.set_override('url',
                              os.environ.get("GNOCCHI_TEST_INDEXER_URL"),
                              'indexer')

        # TODO(jd) It would be cool if Gabbi was able to use the null://
        # indexer, but this makes the API returns a lot of 501 error, which
        # Gabbi does not want to see, so let's just disable it.
        if conf.indexer.url is None or conf.indexer.url == "null://":
            raise case.SkipTest("No indexer configured")

        # Use the presence of DEVSTACK_GATE_TEMPEST as a semaphore
        # to signal we are not in a gate driven functional test
        # and thus should override conf settings.
        if 'DEVSTACK_GATE_TEMPEST' not in os.environ:
            conf.set_override('driver', 'file', 'storage')
            conf.set_override('coordination_url', coordination_url, 'storage')
            conf.set_override('policy_file',
                              os.path.abspath('etc/gnocchi/policy.json'),
                              group="oslo_policy")
            conf.set_override('file_basepath', data_tmp_dir, 'storage')

        # NOTE(jd) All of that is still very SQL centric but we only support
        # SQL for now so let's say it's good enough.
        url = sqlalchemy_url.make_url(conf.indexer.url)

        url.database = url.database + str(uuid.uuid4()).replace('-', '')
        db_url = str(url)
        conf.set_override('url', db_url, 'indexer')
        sqlalchemy_utils.create_database(db_url)

        index = indexer.get_driver(conf)
        index.connect()
        index.upgrade()

        conf.set_override('pecan_debug', False, 'api')

        # Turn off any middleware.
        conf.set_override('middlewares', [], 'api')

        self.index = index

def createdb():
    print "Connecting to %s" % settings.SQLALCHEMY_DATABASE_URI
    engine = create_engine(settings.SQLALCHEMY_DATABASE_URI)
    if settings.DROP_DB_ON_RESTART and database_exists(engine.url):
        print "Dropping old database... (because DROP_DB_ON_RESTART=True)"
        drop_database(engine.url)
    if not database_exists(engine.url):
        print "Creating databases..."
        create_database(engine.url)

    def start_fixture(self):
        """Set up config."""

        self.conf = None
        self.conn = None

        # Determine the database connection.
        db_url = os.environ.get(
            'AODH_TEST_STORAGE_URL', "").replace(
                "mysql://", "mysql+pymysql://")
        if not db_url:
            self.fail('No database connection configured')

        conf = service.prepare_service([], config_files=[])
        # NOTE(jd): prepare_service() is called twice: first by load_app() for
        # Pecan, then Pecan calls pastedeploy, which starts the app, which has
        # no way to pass the conf object so that Paste apps calls again
        # prepare_service. In real life, that's not a problem, but here we want
        # to be sure that the second time the same conf object is returned
        # since we tweaked it. To that, once we called prepare_service() we
        # mock it so it returns the same conf object.
        self.prepare_service = service.prepare_service
        service.prepare_service = mock.Mock()
        service.prepare_service.return_value = conf
        conf = fixture_config.Config(conf).conf
        self.conf = conf
        opts.set_defaults(self.conf)

        conf.set_override('policy_file',
                          os.path.abspath(
                              'aodh/tests/open-policy.json'),
                          group='oslo_policy',
                          enforce_type=True)
        conf.set_override(
            'paste_config',
            os.path.abspath('aodh/tests/functional/gabbi/gabbi_paste.ini'),
            group='api',
        )

        conf.set_override('pecan_debug', True, group='api',
                          enforce_type=True)

        parsed_url = urlparse.urlparse(db_url)
        if parsed_url.scheme != 'sqlite':
            parsed_url = list(parsed_url)
            parsed_url[2] += '-%s' % str(uuid.uuid4()).replace('-', '')
            db_url = urlparse.urlunparse(parsed_url)

        conf.set_override('connection', db_url, group='database',
                          enforce_type=True)

        if (parsed_url[0].startswith("mysql")
           or parsed_url[0].startswith("postgresql")):
            sqlalchemy_utils.create_database(conf.database.connection)

        self.conn = storage.get_connection_from_config(self.conf)
        self.conn.upgrade()

def createDatabase(dbName):
    """Create specified database if it doesn't exist."""
    config = CONFIG_DB
    connectString = "postgresql://{}:{}@{}:{}/{}".format(
        config["username"], config["password"], config["host"], config["port"], dbName
    )

    if not sqlalchemy_utils.database_exists(connectString):
        sqlalchemy_utils.create_database(connectString)

 def _create_new_database(cls, url):
     """Used by testing to create a new database."""
     purl = sqlalchemy_url.make_url(
         cls.dress_url(
             url))
     purl.database = purl.database + str(uuid.uuid4()).replace('-', '')
     new_url = str(purl)
     sqlalchemy_utils.create_database(new_url)
     return new_url

def initialize(re_createTable= False):
    if re_createTable :
        if not database_exists(engine.url):
            create_database(DATABASE.url)

        print(database_exists(engine.url))
        Base.metadata.drop_all(DATABASE, checkfirst = True)


    Base.metadata.create_all(DATABASE, checkfirst = True)

 def setUp(self):
     self.app = self.create_app()
     
     self.db = DB(engine,session,meta)
     import sqlalchemy_utils as squ
     if squ.database_exists(self.db.engine.url):
         squ.drop_database(self.db.engine.url)
     squ.create_database(self.db.engine.url)
     meta.bind = self.db.engine
     meta.create_all()

def check_schema(schema):
    url = db.engine.url

    if url.database != schema:
        copy_url = copy.copy(url)
        copy_url.database = schema
        url = copy_url

    if not database_exists(url):
        create_database(url)

    def setUpClass(cls):
        cls.engine = create_engine('postgresql+psycopg2://[email protected]/monitor_test')

        if not database_exists(cls.engine.url):
            create_database(cls.engine.url, template='template_postgis')

        model.create_database(cls.engine, drop=True)

        cls.monitor = StatusMonitor(cls.engine)
        cls.monitor.read_expected_csv(os.path.join(test_dir, 'data', 'expected-rates.csv'))