class UserModel(DB.Model): """ User model has user related functionality such as saving and retrieving from db""" __tablename__ = "user" id = DB.Column(DB.Integer, primary_key=True) email = DB.Column(DB.String(80)) password = DB.Column(DB.String(80)) def __init__(self, email: str, password: str): self.email = email self.password = password def save_to_db(self): """ Saves (UserModel) object to database""" DB.session.add(self) DB.session.commit() def to_json(self) -> dict: """ returns dict representation of (UserModel)""" return {"id": self.id, "email": self.email, "password": self.password} @classmethod def find_by_email(cls, email: str) -> "UserModel": """Gets user with given email from database :param email(String) email of the user """ return cls.query.filter_by(email=email).first() or None @classmethod def find_by_id(cls, _id: int) -> "UserModel": """Gets user with given id from database :param _id(int) id of the user """ return cls.query.filter_by(id=_id).first() or None
def test_a_models_and_utils(self): """ test OneHundredReport model """ logging.info('\nStart model test..') inst = OneHundredReport(**self._data) DB.add(inst) res = DB.query(OneHundredReport).all() model = res.pop() self.assertEqual(str(model), '1_1_2010-05-01') self.assertDictEqual(model_to_dict(model), \ {'REGN': 1, 'PLAN': 'А', 'NUM_SC': '10207', 'A_P': '2', 'VR': 23064358, 'VV':\ 0, 'VITG': 23064358.0, 'ORA': 0, 'OVA': 0, 'OITGA': 0.0, 'ORP': 0, 'OVP': 0,\ 'OITGP': 0.0, 'IR': 23064358, 'IV': 0, 'IITG': 23064358.0, 'DT':\ '2010-05-01', 'PRIZ': 1, 'P_K':1})
def export_data(): n = ("Beginning export process. Writing files to {}.".format( APPLICATION_PATH + EXPORT_FILE_PATH)) yield ("<p>" + n) # db = DataSet('sqlite:///' + DATABASE_PATH) db = DataSet(DB.dataset_connection()) if os.path.isdir(APPLICATION_PATH + EXPORT_FILE_PATH) is False: os.makedirs(APPLICATION_PATH + EXPORT_FILE_PATH) with db.transaction(): for table_name in db.tables: if not table_name.startswith("page_search"): table = db[table_name] n = "Exporting table: " + table_name yield ('<p>' + n) filename = APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_name + '.json' table.freeze(format='json', filename=filename) db.close() n = "Export process ended. <a href='{}'>Click here to continue.</a>".format( BASE_URL) yield ("<p>" + n)
def test_one_hundred_report_endpoint(self): """ test for one_hundred_report """ logging.info('\nStart endpoint test..') DB.add(OneHundredReport(**self._data)) resp = json.loads(self._client.get('/one_hundred_report/1').\ get_data().decode()) self.assertListEqual( [{'A_P': '2', 'DT': '2010-05-01T00:00:00', 'IITG': 23064358, 'IR':\ 23064358.0, 'IV': 0.0, 'NUM_SC': '10207', 'OITGA': 0.0, 'OITGP': 0.0, 'ORA':\ 0.0, 'ORP': 0.0, 'OVA': 0.0, 'OVP': 0.0, 'PLAN': 'А', 'PRIZ': 1, 'P_K': 1,\ 'REGN': 1, 'VITG': 23064358.0, 'VR': 23064358.0, 'VV': 0.0}, {'A_P': '2', 'DT':\ '2010-05-01T00:00:00', 'IITG': 23064358, 'IR': 23064358.0, 'IV': 0.0, 'NUM_SC':\ '10207', 'OITGA': 0.0, 'OITGP': 0.0, 'ORA': 0.0, 'ORP': 0.0, 'OVA': 0.0, 'OVP':\ 0.0, 'PLAN': 'А', 'PRIZ': 1, 'P_K': 2, 'REGN': 1, 'VITG': 23064358.0, 'VR': 23064358.0, 'VV': 0.0}], resp)
def import_data(): from settings import DB n = [] n.append("Beginning import process.") # yield "<p>" + n n.append("Cleaning DB.") # yield "<p>" + n try: DB.clean_database() except: from core.models import init_db init_db.recreate_database() DB.remove_indexes() n.append("Clearing tables.") # yield "<p>" + n xdb = DataSet(DB.dataset_connection()) # with xdb.atomic() as txn: try: with xdb.transaction(): for table_name in xdb.tables: n.append("Loading table " + table_name) # yield "<p>" + n try: table = xdb[table_name] except: n.append("<p>Sorry, couldn't create table ", table_name) else: filename = (APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_name + '.json') if os.path.exists(filename): try: table.thaw(format='json', filename=filename, strict=True) except Exception as e: n.append("<p>Sorry, error:{}".format(e)) else: n.append("No data for table " + table_name) # yield "<p>" + n except Exception as e: n.append('Ooops: {}'.e) else: xdb.query(DB.post_import()) xdb.close() DB.recreate_indexes() n.append( "Import process ended. <a href='{}'>Click here to continue.</a>". format(BASE_URL)) return '<p>'.join(n)
def test_03_query_corp(self): Browser.dr.get(self.base_url) self.page.search_querydropdownbtn().click() self.page.search_querycropcodeinp().send_keys('001') self.page.search_selectcropstatusinput().click() self.page.crop_status_options()[1].click() self.page.serach_querybtn().click() with DB() as dbcur: sql = "select * from corp where code = '001';" count = dbcur.execute(sql) li_tr = self.page.query_corptr() logger.info(pytest.assume(len(li_tr) == count))
def import_data(): n = ("Beginning import process.") yield "<p>" + n DB.clean_database() xdb = DataSet(DB.dataset_connection()) xdb.query(DB.pre_import(), commit=False) with xdb.transaction() as txn: for table_name in xdb.tables: xdb.query('DELETE FROM `{}`;'.format(table_name), commit=True) with xdb.transaction() as txn: for table_name in xdb.tables: n = ("Loading table " + table_name) yield "<p>" + n try: table = xdb[table_name] except: yield ("<p>Sorry, couldn't create table ", table_name) else: filename = (APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_name + '.json') if os.path.exists(filename): table.thaw(format='json', filename=filename, strict=True) else: n = ("No data for table " + table_name) yield "<p>" + n xdb.query(DB.post_import()) xdb.close() DB.recreate_indexes() n = "Import process ended. <a href='{}'>Click here to continue.</a>".format( BASE_URL) yield "<p>" + n from core.routes import app app.reset()
def opt8(): ''' Realiza o backup do Banco de Dados ''' subprocess.call('clear') name = raw_input('Nome do arquivo de Backup: ') dest = raw_input('Salvar em: ') try: if dest[-1] != '/': dest = dest + '/' bckfile = ''.join([dest, name, '-', datetime.today().strftime('%d-%m-%Y-%H-%M-%S'), '.tar']) with tarfile.open(bckfile, 'a') as tf: tf.add('{0}{1}'.format(INSTALL_PATH, DB), DB.split('/')[-1]) print 'Backup realizado com sucesso.\n{0}'.format(bckfile) except: print 'Falha ao gerar arquivo de backup.'
def site_search_results(request, site=None): try: search_terms = request.query['search'] except KeyError: raise KeyError('No search field in query.') if search_terms == "": raise ValueError('Search field is empty.') search_terms_enc = utf8_escape(search_terms) pages_searched = DB.site_search(search_terms_enc, site) return pages_searched, search_terms
def parse(arg, DEBUG=False): # define DB db = DB(DEBUG) # load revisions from database and store in format # {id1: [revision1, revison2], id2: [rev3] ... } revisions = defaultdict(list, get_revisions(db)) # buffers for accumulating processed data before save insertList = [] updateList = [] # iterating through generator for row in reader(arg): uid = row['uid'] # creating hash from processed record # duplicates will have same hash, so we can ignore them row_hash = hash_from_dict(row) # check if hash in revisions if uid in revisions and row_hash in revisions[uid]: continue # write hash to our record, so we will able to extract in during next parse row['revisions'] = [row_hash] if uid in revisions: updateList.append(row) else: insertList.append(row) # add hash to revision, so we can omit following duplicates of current parse revisions[uid].append(row_hash) # save data to DB when localstorage reaches chunk size if CHANK_SIZE in [len(insertList), len(updateList)]: save(db, insertList, updateList) insertList.clear() updateList.clear() # saving the rest of the data (if any) to DB save(db, insertList, updateList)
def create_tables(): """create local database if it doesn't exist""" if ENV == "local": DB.create_all()
result = db.products.update_one({'uid': item['uid']}, query) def get_revisions(db): products = db.products if products.count() > 0: return dict([(i['uid'], i['revisions']) for i in \ products.find({}, {'uid': 1, 'revisions': 1, '_id': 0})]) else: return {} def drop_table(db): db.products.drop() def create_index(db): db.products.create_index([('uid', ASCENDING)], unique=True) # You can use this script for clearing DB and creating indexes # python db.py 1 - testing DataBase # python db.py 0 - production DataBase if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("debug") args = parser.parse_args() arg = False if args.debug in ['0', 0, 'False', 'false', ''] else True drop_table(DB(arg)) create_index(DB(arg))
def get_next_pk(sequence_name): return DB.command('findAndModify', 'sequences', query={'_id': sequence_name}, update={'$inc': {'pk': 1}}, new=True)['value']['pk']
import os from settings import DB from lqueries import clear_agg_sql from lqueries import clear_hex_sql from lqueries import clear_results_hex_sql from lqueries import clear_totals_hex_sql from lqueries import clear_preprocessed_sql from lqueries import update_hex_seq # Restrict visible functions __all__ = ['init'] # LOCAL PATHS cwd = os.path.dirname(__file__) scripts_path = os.path.join(cwd, '../scripts/DB') dbname = DB.split('/')[-1] # ####################### HELPER FUNCTIONS ################################ def load(arr): '''load csvfiles into postgres table it expects an array of tuples in the following format ('table_name', 'path', 'csv_fname') or ('table_name', 'path') assumes the csv_fname is the same as the table name path: relative to the data folder ''' cmd = '%(path)s/load_pg_table.sh %(db)s %(table)s %(csv_path)s' with lcd(cwd): for t in arr: abs_path = os.path.join(cwd, '../data', t[1])
def db_recreate(table_name='FileInfo'): ''' Utility function for recreating a database table after changes ''' from core import models table_model = getattr(models, table_name) table_ref = table_model._meta.db_table from settings import DB, EXPORT_FILE_PATH from core.libs.playhouse.dataset import DataSet n = [] n.append("Beginning export process... Writing files to {}.".format(APPLICATION_PATH + EXPORT_FILE_PATH)) xdb = DataSet(DB.dataset_connection()) if os.path.isdir(APPLICATION_PATH + EXPORT_FILE_PATH) is False: os.makedirs(APPLICATION_PATH + EXPORT_FILE_PATH) with xdb.transaction(): table = xdb[table_ref] n.append("Exporting table: " + table_name) filename = APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_ref + '.json' table.freeze(format='json', filename=filename) xdb.close() n.append("Export process ended.") with db.atomic(): db.drop_tables((table_model,), safe=True) db.create_tables((table_model,), safe=False) try: with xdb.transaction(): n.append("Loading table " + table_name) try: table = xdb[table_ref] except: n.append("<p>Sorry, couldn't create table ", table_name) else: filename = (APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_ref + '.json') if os.path.exists(filename): try: table.thaw(format='json', filename=filename, strict=True) except Exception as e: n.append("<p>Sorry, error:{}".format(e)) else: n.append("No data for table " + table_name) except Exception as e: n.append('Ooops: {}'.e) else: xdb.query(DB.post_import()) xdb.close() # DB.recreate_indexes() n.append("Import process ended.") return ('<p>'.join(n))
from core.error import LoggedException from functools import wraps from core.libs.bottle import request from core.libs.peewee import OperationalError from core.models import db from settings import DB, DATABASE_TIMEOUT, RETRY_INTERVAL from sys import exc_info from time import clock, sleep DBError, error_text = DB.db_warnings() # what we might want to do is instead subclass transaction # so we can use it without the decorator context def transaction(func): @wraps(func) def wrapper(*a, **ka): db.connect() db.execute_sql('PRAGMA journal_mode=WAL;') db.execute_sql('PRAGMA busy_timeout=30000;') start = clock() while 1: try: with db.transaction(): fn = func(*a, **ka) except LoggedException as e: db.rollback() raise exc_info()[0](e.msg) except DBError as e:
_init_logging(CONSOLE_FORMAT, CONSOLE_DATE_FORMAT, LOGGING_LEVEL) _configure_app(APP_CONFIGURATION) logger = logging.getLogger(__name__) api = Api(app) jwt = JWTManager(app) @jwt.expired_token_loader def expired_token_handler_callback(expired_token): """set response status and body for when jwt token expires""" token_type = expired_token["type"] return jsonify({ "status": 401, "message": f"{token_type}_token_expired" }), 401 # routes api.add_resource(RegisterUser, "/register") api.add_resource(LoginUser, "/authenticate") api.add_resource(GetTodos, "/todos") api.add_resource(PostTodos, "/todo") api.add_resource(ModifyTodos, "/todo/<string:todo_id>") if __name__ == "__main__": debug = ENV != "prod" DB.init_app(app) app.run(port=PORT, debug=debug)
from core.error import LoggedException from functools import wraps from core.libs.bottle import request from core.libs.peewee import OperationalError from core.models import db from settings import DB, DATABASE_TIMEOUT, RETRY_INTERVAL from sys import exc_info from time import clock, sleep DBError, error_text = DB.db_warnings() # what we might want to do is instead subclass transaction # so we can use it without the decorator context def transaction(func): @wraps(func) def wrapper(*a, **ka): db.connect() db.execute_sql('PRAGMA journal_mode=WAL;') db.execute_sql('PRAGMA busy_timeout=30000;') start = clock() while 1: try: with db.transaction(): fn = func(*a, **ka) except LoggedException as e: db.rollback() raise exc_info()[0](e.msg) except DBError as e: db.rollback()
class TodoModel(DB.Model): """Todo model has all todo related functionality such as saving and retrieving from db""" __tablename__ = "todo" id = DB.Column(DB.Integer, primary_key=True) title = DB.Column(DB.String(256), nullable=False) desc = DB.Column(DB.String(256), nullable=True) status = DB.Column(DB.Boolean, nullable=False) created_at = DB.Column(DB.DateTime, default=datetime.utcnow()) updated_at = DB.Column(DB.DateTime) owner = DB.Column(DB.Integer, DB.ForeignKey("user.id")) user = DB.relationship("UserModel") def __init__(self, title: str, desc: str, status: bool, owner: int): self.title = title self.desc = desc self.status = status self.owner = owner def to_json(self) -> dict: """ returns dict representation of the object""" return { "id": self.id, "title": self.title, "desc": self.desc, "status": self.status, "owner": self.owner, } def save_to_db(self): """Save (TodoModel) into db""" DB.session.add(self) DB.session.commit() def delete_from_db(self): """Delete (TodoModel) from db""" DB.session.delete(self) DB.session.commit() @classmethod def find_by_user(cls, user_id: str) -> "TodoModel": """return all todo items where owner is user_id""" return cls.query.filter_by(owner=user_id).all() @classmethod def find_by_id(cls, _id: int) -> "TodoModel": """returns one todo by id""" return cls.query.filter_by(id=_id).first()
def step_4_pre(): if get_ini('main', 'DO_DB_CHECK') is None: store_ini('main', 'DO_DB_CHECK', 'Y') from core.utils import reboot reboot() report = [] from core.models import db, Template try: db.connect() except: raise db.close() report.append("Database connection successful.") from settings import DB DB.recreate_database() report.append("Database tables created successfully.") username = "******" email = get_ini("user", "email") password = get_ini("user", "password") blog_path = get_ini("install", "blog_path") from core.utils import encrypt_password p_key = get_ini('key', 'PASSWORD_KEY') password = encrypt_password(password, p_key) db.connect() with db.atomic(): from core.models import Site new_site = Site.create( name="Your first site", description="The description for your first site.", url=get_ini('main', 'base_url_root'), path=blog_path) report.append("Initial site created successfully.") from core.models import User new_user = User( name='Administrator', email=email, encrypted_password=password) new_user.save_pwd() from core.auth import role new_user_permissions = new_user.add_permission( permission=role.SYS_ADMIN, site=new_site ) new_user_permissions.save() report.append("Initial admin user created successfully.") plugindir = _join((_s.APPLICATION_PATH, 'data', 'plugins')) import shutil # TODO: warn on doing this? # this should only happen with a totally fresh install, not an upgrade install_directory = _join((_s.APPLICATION_PATH, _s.INSTALL_SRC_PATH)) if (os.path.isdir(plugindir)): shutil.rmtree(plugindir) shutil.copytree(_join((install_directory, 'plugins')), plugindir) report.append("Default plugins copied successfully to data directory.") themedir = _join((_s.APPLICATION_PATH, 'data', 'themes')) if (os.path.isdir(themedir)): shutil.rmtree(themedir) shutil.copytree(_join((install_directory, 'themes')), themedir) report.append("Default themes copied successfully to data directory.") from core import plugins for x in os.listdir(plugindir): if (os.path.isdir(_join((plugindir, x))) is True and x != '__pycache__'): new_plugin = plugins.register_plugin(x, enable=True) report.append("New plugin '{}' installed successfully.".format( new_plugin.name)) from settings.defaults import DEFAULT_THEME from core.models import Theme new_theme = Theme.install_to_system(DEFAULT_THEME) report.append("Default theme created and installed successfully to system.") from core.models import Blog new_blog = Blog( site=new_site, name="Your first blog", description="The description for your first blog.", url=new_site.url, path=new_site.path, local_path=new_site.path, theme=new_theme ) # TODO: add blog-level permission for new user as well new_blog.setup(new_user, new_theme) # TODO: Add default post report.append("Initial blog created successfully with default theme.") db.close() output_file_name = _join((_s.APPLICATION_PATH + _s.DATA_FILE_PATH, _s.INI_FILE_NAME)) config_parser = ConfigParser() sections = ('db', 'path', 'key') for s in sections: for name, value in parser.items(s): try: config_parser.add_section(s) except DuplicateSectionError: pass config_parser.set(s, name, value) # if request.environ['HTTP_HOST'] == _s.DEFAULT_LOCAL_ADDRESS + _s.DEFAULT_LOCAL_PORT: # config_parser.add_section('server') # config_parser.set('server', 'DESKTOP_MODE', 'True') try: with open(output_file_name, "w", encoding='utf-8') as output_file: config_parser.write(output_file) except BaseException as e: raise SetupError(str(e.__class__.__name__) + ": " + str(e)) try: os.remove(config_file_name) except OSError as e: from core.error import not_found if not_found(e) is False: raise e except Exception as e: raise e finished = ''' <p>Installation is complete. <a href="{}">Return to the main page to begin using the application.</a> <script> $.get('/reboot',function(data){{}}); </script> '''.format(_s.BASE_URL) return {'report':report, 'finished':finished}
def db_recreate(table_name='FileInfo'): ''' Utility function for recreating a database table after changes ''' from core import models table_model = getattr(models, table_name) table_ref = table_model._meta.db_table from settings import DB, EXPORT_FILE_PATH from core.libs.playhouse.dataset import DataSet n = [] n.append("Beginning export process... Writing files to {}.".format( APPLICATION_PATH + EXPORT_FILE_PATH)) xdb = DataSet(DB.dataset_connection()) if os.path.isdir(APPLICATION_PATH + EXPORT_FILE_PATH) is False: os.makedirs(APPLICATION_PATH + EXPORT_FILE_PATH) with xdb.transaction(): table = xdb[table_ref] n.append("Exporting table: " + table_name) filename = APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_ref + '.json' table.freeze(format='json', filename=filename) xdb.close() n.append("Export process ended.") with db.atomic(): db.drop_tables((table_model, ), safe=True) db.create_tables((table_model, ), safe=False) try: with xdb.transaction(): n.append("Loading table " + table_name) try: table = xdb[table_ref] except: n.append("<p>Sorry, couldn't create table ", table_name) else: filename = (APPLICATION_PATH + EXPORT_FILE_PATH + '/dump-' + table_ref + '.json') if os.path.exists(filename): try: table.thaw(format='json', filename=filename, strict=True) except Exception as e: n.append("<p>Sorry, error:{}".format(e)) else: n.append("No data for table " + table_name) except Exception as e: n.append('Ooops: {}'.e) else: xdb.query(DB.post_import()) xdb.close() # DB.recreate_indexes() n.append("Import process ended.") return ('<p>'.join(n))
def step_4_pre(): if get_ini('main', 'DO_DB_CHECK') is None: store_ini('main', 'DO_DB_CHECK', 'Y') from core.utils import reboot reboot() report = [] from core.models import db, Template try: db.connect() except: raise db.close() report.append("Database connection successful.") from settings import DB DB.recreate_database() report.append("Database tables created successfully.") username = "******" email = get_ini("user", "email") password = get_ini("user", "password") blog_path = get_ini("install", "blog_path") from core.utils import encrypt_password p_key = get_ini('key', 'PASSWORD_KEY') password = encrypt_password(password, p_key) db.connect() with db.atomic(): from core.models import Site new_site = Site.create( name="Your first site", description="The description for your first site.", url=get_ini('main', 'base_url_root'), path=blog_path) report.append("Initial site created successfully.") from core.models import User new_user = User(name='Administrator', email=email, encrypted_password=password) new_user.save_pwd() from core.auth import role new_user_permissions = new_user.add_permission( permission=role.SYS_ADMIN, site=new_site) new_user_permissions.save() report.append("Initial admin user created successfully.") plugindir = _join((_s.APPLICATION_PATH, 'data', 'plugins')) import shutil # TODO: warn on doing this? # this should only happen with a totally fresh install, not an upgrade install_directory = _join((_s.APPLICATION_PATH, _s.INSTALL_SRC_PATH)) if (os.path.isdir(plugindir)): shutil.rmtree(plugindir) shutil.copytree(_join((install_directory, 'plugins')), plugindir) report.append("Default plugins copied successfully to data directory.") themedir = _join((_s.APPLICATION_PATH, 'data', 'themes')) if (os.path.isdir(themedir)): shutil.rmtree(themedir) shutil.copytree(_join((install_directory, 'themes')), themedir) report.append("Default themes copied successfully to data directory.") from core import plugins for x in os.listdir(plugindir): if (os.path.isdir(_join((plugindir, x))) is True and x != '__pycache__'): new_plugin = plugins.register_plugin(x, enable=True) report.append("New plugin '{}' installed successfully.".format( new_plugin.name)) from settings.defaults import DEFAULT_THEME from core.models import Theme new_theme = Theme.install_to_system(DEFAULT_THEME) report.append( "Default theme created and installed successfully to system.") from core.models import Blog new_blog = Blog(site=new_site, name="Your first blog", description="The description for your first blog.", url=new_site.url, path=new_site.path, local_path=new_site.path, theme=new_theme) # TODO: add blog-level permission for new user as well new_blog.setup(new_user, new_theme) # TODO: Add default post report.append("Initial blog created successfully with default theme.") db.close() output_file_name = _join( (_s.APPLICATION_PATH + _s.DATA_FILE_PATH, _s.INI_FILE_NAME)) config_parser = ConfigParser() sections = ('db', 'path', 'key') for s in sections: for name, value in parser.items(s): try: config_parser.add_section(s) except DuplicateSectionError: pass config_parser.set(s, name, value) # if request.environ['HTTP_HOST'] == _s.DEFAULT_LOCAL_ADDRESS + _s.DEFAULT_LOCAL_PORT: # config_parser.add_section('server') # config_parser.set('server', 'DESKTOP_MODE', 'True') try: with open(output_file_name, "w", encoding='utf-8') as output_file: config_parser.write(output_file) except BaseException as e: raise SetupError(str(e.__class__.__name__) + ": " + str(e)) try: os.remove(config_file_name) except OSError as e: from core.error import not_found if not_found(e) is False: raise e except Exception as e: raise e finished = ''' <p>Installation is complete. <a href="{}">Return to the main page to begin using the application.</a> <script> $.get('/reboot',function(data){{}}); </script> '''.format(_s.BASE_URL) return {'report': report, 'finished': finished}
with open_workbook(fname) as wb: s = wb.sheet_by_index(2) for row in range(1, s.nrows): SubscriptionArticle.get_or_create( subscription=s.cell(row, 0).value, article=s.cell(row, 1).value ) return if __name__ == '__main__': print('Using PRODUCTION database? %s' % SETTINGS['PRODUCTION_FLAG']) if len(sys.argv) > 1 and sys.argv[1] == '--nointeraction': pass else: r = input( 'Deleting and initializing tables, press Enter to continue...\n') if r: print('Aborted') sys.exit(1) tables = [Subscription, Article, SubscriptionArticle] create_tables(tables, reset=True) # abs_path = os.path.abspath(__file__) # cur_dir = os.path.dirname(abs_path) # test_url = os.path.join(cur_dir, 'test/data/test_url.xlsx') # feed_subscription_url_from_xml(test_url) # feed_article_url_from_xls(test_url) # feed_subscription_article_from_xls(test_url) POSTGRES_DB.close()