def load_fixtures_():
for fixture_dir in current_app.config.get(
'FIXTURES_DIRS',
[os.path.join(current_app.root_path, 'fixtures')]):
for fixture_file in sorted(glob.glob(fixture_dir + '/*.yml')):
fixtures = YAMLLoader().load(fixture_file)
load_fixtures(db, fixtures)
def run(self):
db.drop_all()
# Setup the database
db.create_all()
# Rollback any lingering transactions
db.session.rollback()
# Construct a list of paths within which fixtures may reside
default_fixtures_dir = os.path.join(current_app.root_path, 'fixtures')
# All relative paths should be relative to the app's root directory.
fixtures_dirs = [default_fixtures_dir]
# Load all of the fixtures
for filename in config.FIXTURES_LIST.split(","):
for directory in fixtures_dirs:
filepath = os.path.join(directory, filename)
if not os.path.exists(filepath):
continue
load_fixtures(db, loaders.load(filepath))
break
else:
raise IOError(
"Error loading '{0}'. File could not be found".format(
filename))
def load_fixtures(self, file_name):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
for document in Document.all():
index_document(document)
self.update_index()
def load_fixtures(self, file_name):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
update_collections()
for doc in Document.all():
process_document(doc)
self.flush_index()
def create_db():
"""Creates the db tables."""
database.db.create_all()
get_ulm()
for fixture_file in glob.glob(config.DevelopmentConfig.FIXTURES_DIRS +
'/*.json'):
fixtures = JSONLoader().load(fixture_file)
load_fixtures(database.db, fixtures)
MigrationManager().stamp_db()
def load_fixtures(self, file_name, process_documents=True):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
reindex_entities()
if process_documents:
for doc in Document.all():
process_document(doc)
self.flush_index()
def load_fixtures(self, file_name, process_documents=True):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
reindex_entities()
if process_documents:
for doc in Document.all():
analyze_document(doc)
optimize_search()
def load_fixtures(self, file_name, process_documents=True):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
reindex_entities()
if process_documents:
for doc in Document.all():
analyze_document(doc)
optimize_search()
def load_fixtures():
"""
Loads database fixtures
"""
import glob
from flask_fixtures.loaders import YAMLLoader
from flask_fixtures import load_fixtures
db.drop_all()
db.create_all()
for fixture_dir in app.config.get('FIXTURES_DIRS', ['./fixtures/']):
for fixture_file in glob.glob(fixture_dir + '/*.yml'):
fixtures = YAMLLoader().load(fixture_file)
load_fixtures(db, fixtures)
def init_database():
from glob import glob
from flask_fixtures.loaders import JSONLoader
from flask_fixtures import load_fixtures
db.drop_all()
db.create_all()
base_dir = abspath(dirname(__file__))
for fixture_file in glob(join(base_dir, 'fixtures', '*.json')):
fixtures = JSONLoader().load(fixture_file)
load_fixtures(db, fixtures)
yield db
db.drop_all()
def setUp(self):
app_settings = os.getenv('APP_SETTINGS',
'bee_api.config.TestingConfig')
app.config.from_object(app_settings)
fixture_files = os.path.join(
os.path.dirname(os.path.realpath(__file__)), '..', 'fixtures',
'*json')
with app.app_context():
db.create_all()
for fixture_file in glob.glob(fixture_files):
fixtures = JSONLoader().load(fixture_file)
load_fixtures(db, fixtures)
app.testing = True
self.app = app.test_client()
def init_database(request):
"""Initializes the database """
DB.drop_all()
DB.create_all()
base_dir = join(abspath(dirname(__file__)), '..')
for fixture_file in glob(join(base_dir, 'seed', '*.json')):
fixtures = JSONLoader().load(fixture_file)
load_fixtures(DB, fixtures)
for fixture_file in sorted(glob(join(base_dir, 'seed', 'demo', '*.json'))):
fixtures = JSONLoader().load(fixture_file)
load_fixtures(DB, fixtures)
request.cls.DB = DB
yield DB
close_all_sessions()
def seed_command(directory, demo):
"""
Populate database with seed data
[DIR] - directory location of fixtures files, defaults to 'seed'
[DEMO] - load demo data, defaults to 'false'
"""
if not exists(directory):
print("Directory, {}, doesn't exist ... exiting".format(directory))
return False
base_dir = abspath(dirname(__file__))
print("Seeding Database")
print(APP.config['SQLALCHEMY_DATABASE_URI'])
for fixture_file in glob(join(base_dir, directory, '*.json')):
fixtures = JSONLoader().load(fixture_file)
try:
load_fixtures(DB, fixtures)
except IntegrityError as err:
# rollback required, so subsequent files may be processed
DB.session.rollback()
print('It appears, {}, was already processed'.format(fixture_file))
print("Processed fixture file: {}".format(fixture_file))
if demo:
print("Loading Demo Data")
for fixture_file in glob(join(base_dir, directory, 'demo', '*.json')):
fixtures = JSONLoader().load(fixture_file)
try:
load_fixtures(DB, fixtures)
except IntegrityError as err:
# rollback required, so subsequent files may be processed
DB.session.rollback()
print('It appears, {}, was already processed'.format(
fixture_file))
print("Processed fixture file: {}".format(fixture_file))
return True
from iws_fr.models import db
db.create_all()
elif args.command == 'loaddata':
# Note: The load_fixtures function isn't in flask_fixtures public API.
from iws_fr.models import db
import json
from flask_fixtures import load_fixtures
fixtures_directory = os.path.join('iws_fr', 'fixtures')
fixtures = os.listdir(fixtures_directory)
for fixture in sorted(fixtures):
fixture_directory = os.path.join(fixtures_directory, fixture)
with open(fixture_directory) as fixture_file:
fixture_data = json.loads(fixture_file.read(),
object_hook=date_deserialize)
load_fixtures(db, fixture_data)
elif args.command == 'runserver':
# TODO: Update to flask run cmdline.
# TODO: libsass to compile css?
# https://stackoverflow.com/questions/9508667/reload-flask-app-when-template-file-changes
# https://hongminhee.org/libsass-python/
# http://flask.pocoo.org/docs/0.12/server/
# https://github.com/arnaudlimbourg/heroku-libsass-python
# https://codepen.io/adwylie/
# https://github.com/postcss/autoprefixer
# cssnano
import iws_fr.views
app.run()
def load_fixtures(self, file_name):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
self.update_index()
init_db - populate the database with initial data. Make sure to run this
after create_db is run.
drop_db - drop the current database with data
"""
description = """Utility function for running various flask commands."""
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=description, formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('command', help=help_string)
args = parser.parse_args()
if args.command == 'runserver':
app.run()
elif args.command == 'drop_db':
models.db.drop_all()
elif args.command == 'create_db':
models.db.create_all()
elif args.command == 'init_db':
# initialize data for the created db
fixture_dir_path = os.path.join('fr_app', 'fixtures')
# we know that no dirs are there in the fixtures path, so safe to
# iterate
for fixture in os.listdir(fixture_dir_path):
fixture_path = os.path.join(fixture_dir_path, fixture)
with open(fixture_path, 'r') as infile:
load_fixtures(models.db, json.loads(infile.read()))
def load_fixtures(self, file_name):
filepath = self.get_fixture_path(file_name)
load_fixtures(db, loaders.load(filepath))
db.session.commit()
self.update_index()
def _load_fixtures(app, db):
for fixture in app.config.get('STARTUP_FIXTURES', []):
load_fixtures(
db, loaders.load(os.path.join(app.root_path, 'fixtures', fixture)))
from app import app, db
import glob
from flask_fixtures.loaders import JSONLoader
from flask_fixtures import load_fixtures
# Destroy
db.drop_all()
# Recreate Structure
db.create_all()
# Import fixture data
for fixture_dir in app.config.get('FIXTURES_DIRS', ['./app/fixtures']):
for fixture_file in glob.glob(fixture_dir + '/*.json'):
fixtures = JSONLoader().load(fixture_file)
load_fixtures(db, fixtures)
