def test_init_database(self):
setting = models.get_uuid(self.session)
self.assertEqual(None, setting)
models.init_database(self.session)
setting = models.get_uuid(self.session)
uuid_real = uuid.UUID(setting.value)
self.assertEqual(len(uuid_real.hex), 32)
def main() -> None:
init_database(settings.database.filename)
updater = Updater(settings.bot.token)
dispatcher = updater.dispatcher
register_controllers(dispatcher)
updater.start_polling()
updater.idle()
def main():
"""
Méthode de démarrage de l'application
"""
init_database()
root = tk.Tk()
root.wm_title("Simply Movie")
root.minsize(300, 300)
SimplyMovie(root)
root.mainloop()
def run(db_url, conf=None):
if conf is not None:
cherrypy.config.update(conf)
init_database(db_url)
create_nonexistent_tables()
static_conf = {
'/': {
'tools.staticdir.root': path.join(path.dirname(path.abspath(__file__)), 'static'),
'tools.staticdir.on': True,
'tools.staticdir.dir': '.',
'tools.staticdir.index': 'index.html'
}
}
cherrypy.tree.mount(StaticServer(), '/', static_conf)
cherrypy.tree.mount(ApiServer(), '/api')
cherrypy.engine.start()
cherrypy.engine.block()
def main():
if '--initdatabase' in sys.argv:
# initialize database
app.logger.info("initialize database")
models.init_database(sys.argv)
sys.exit(0)
elif '--createadmin' in sys.argv or '--createsuperuser' in sys.argv:
# creating an admin user from command line
success, msg = models.create_admin_cli(sys.argv)
if success:
app.logger.info('creating admin user "{}"'.format(msg))
print("success")
else:
app.logger.error('problems creating admin user {}')
print("failed: {}".format(msg))
sys.exit(1)
sys.exit(0)
else:
# check if the user wants to set port and host from command line
port = 5000
host = '127.0.0.1'
debug = False
for arg in sys.argv:
if 'port=' in arg.lower():
port = int(arg.replace('port=', ''))
if 'host=' in arg.lower():
host = arg.replace('host=', '').split(':')
if len(host) > 1:
port = int(host[1])
host = host[0]
if 'debug=true' in arg.lower():
debug = True
app.logger.info("starting app on host={} port={} debug={}".format(
host, port, debug))
app.run(host=host, port=port, debug=debug)
def init_database(self):
"""
Initializes the database tables and relationships
:return: None
"""
init_database(self.engine)
def test_should_raise_error_for_unsupported_databases():
with pytest.raises(ValueError):
init_database("")
# Create a parser for each low-level module
module_basename = module.__name__.split('.')[-1]
module_parser = command_subparsers.add_parser(module_basename)
# Add default arguments for each fetcher (database configuration)
module_parser.add_argument(
'--db',
default='sqlite',
help="which type of database to use (postgres, sqlite). Defaults to sqlite."
)
module_parser.add_argument(
'--db-config',
help="Name of file containing database configuration."
)
# Each module defines additional arguments
module.configure_parser(module_parser)
module_parser.set_defaults(func=module.main)
# Parse arguments
args = parser.parse_args()
# Initialize database
init_database(args.db, config_filename=args.db_config)
create_tables()
# Invoke the main program that was specified by the submodule
if args.func is not None:
args.func(**vars(args))
from models import init_database init_database()
import overpy
import json
import logging
from geofence import Geofences
from models import Gym, init_database
from utils import get_args
args = get_args
app = None
log = logging.getLogger(__name__)
db = init_database(app)
def ex_query(s, w, n, e):
# Query Overpass for known gym areas
api = overpy.Overpass(xml_parser=0)
result = api.query("""
[out:json]
[date:"2016-07-10T00:00:00Z"]
[timeout:620]
[bbox:{},{},{},{}];
(
//Tags that are confirmed to classify gyms as 'parks' for EX Raids
way[leisure=park];
way[landuse=recreation_ground];
way[leisure=recreation_ground];
way[leisure=pitch];
way[leisure=garden];
way[leisure=golf_course];
from flask import Flask, render_template
from flask_bootstrap import Bootstrap
from models import init_database, Post
app = Flask(__name__)
Bootstrap(app)
init_database('postgres', 'postgres-credentials.json')
@app.route('/')
def hello_world():
#return 'Not dead. Yet.'
ten = Post.select().where(Post.title.contains('Django')).limit(10)
print(ten[0].title)
return render_template('index.html', results=ten)
if __name__ == "__main__":
app.run()
setenv('BALAIO_SETTINGS_FILE', args.configfile)
if args.alembic_configfile:
setenv('BALAIO_ALEMBIC_SETTINGS_FILE', args.alembic_configfile)
activity = args.activity
if activity == 'syncdb':
# Creates all database basic structure including
# Alembic's migration bootstrapping.
if not args.alembic_configfile:
sys.exit('%s: error: argument --alembic-config is required' % __file__)
logger.info('The database infrastructure will be created')
config = utils.balaio_config_from_env()
engine = models.create_engine_from_config(config)
models.init_database(engine)
print 'Done. All databases had been created'
sys.exit(0)
elif activity == 'shell':
# Places de user on an interactive shell, with a
# pre-configured Session object.
local_scope = {}
def Session_factory():
engine = models.create_engine_from_config(
utils.balaio_config_from_env())
models.Session.configure(bind=engine)
return models.Session
# Add default arguments for each fetcher (database configuration)
module_parser.add_argument(
'--db',
default='sqlite',
help=
"which type of database to use (postgres, sqlite). Defaults to sqlite."
)
module_parser.add_argument(
'--db-config',
help="Name of file containing database configuration.")
# Each module defines additional arguments
module.configure_parser(module_parser)
module_parser.set_defaults(func=module.main)
# Add command for running unit tests
test_parser = subparsers.add_parser('tests', description="Run unit tests.")
test_parser.set_defaults(func=run_tests)
# Parse arguments
args = parser.parse_args()
# Initialize database
if args.command != 'tests':
init_database(args.db, config_filename=args.db_config)
create_tables()
# Invoke the main program that was specified by the submodule
if args.func is not None:
args.func(**vars(args))
env_key='LOG_CFG'):
"""Setup logging configuration """
path = default_path
value = os.getenv(env_key, None)
if value:
path = value
if os.path.exists(path):
with open(path, 'rt') as f:
config = json.load(f)
logging.config.dictConfig(config)
else:
logging.basicConfig(level=default_level)
if __name__ == "__main__":
models.init_database()
'''Script to read data via the RESTBUS API and save to a database. '''
parser = argparse.ArgumentParser(description='Read the RestBus API')
parser.add_argument('-o',
'--logfile',
help='JSON file with the logger configuration',
required=True)
parser.add_argument('-r',
'--route',
help='The route number to gather data on',
required=False,
default="1")
parser.add_argument('-a',
'--all',
dest='all',
action='store_true',
def start_server(argv=None):
config = Config()
logging.debug('starting server with argv : %s' % str(argv))
init_database()
bind_address = config.get('bind_address')
bind_port = config.getint('bind_port')
try:
https_port = int(
config.get('https_port')) if config.get('https_port') else None
except ValueError:
logger.warning('https_port is configured, but it is not int, %s' %
config.get('https_port'))
https_port = None
if https_port:
https_sockets = tornado.netutil.bind_sockets(https_port, bind_address)
sockets = tornado.netutil.bind_sockets(bind_port, bind_address)
# task_id is current process identifier when forked processes, start with 0
task_id = None
if not sys.platform.startswith('win'):
task_id = fork_processes(config.getint('fork_proc_count'))
else:
logger.warning(
'Windows platform does not support forking process, running in single process mode.'
)
cluster_sync_obj = None
if task_id is not None and config.get('cluster_bind_address'):
cluster_node = ClusterNode(task_id, config)
cluster_sync_obj = cluster_node.sync_obj
scheduler_manager = SchedulerManager(config=config,
syncobj=cluster_sync_obj)
scheduler_manager.init()
node_manager = NodeManager(scheduler_manager)
node_manager.init()
webhook_daemon = WebhookDaemon(config, SpiderSettingLoader())
webhook_daemon.init()
app = make_app(scheduler_manager, node_manager, webhook_daemon)
server = tornado.httpserver.HTTPServer(app)
server.add_sockets(sockets)
if https_port:
check_and_gen_ssl_keys(config)
if config.getboolean('client_validation'):
ssl_ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
else:
ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_ctx.load_cert_chain(
os.path.join('keys', "%s.crt" % config.get('server_name')),
os.path.join('keys', "%s.key" % config.get('server_name')))
ssl_ctx.load_verify_locations(cafile='keys/ca.crt')
ssl_ctx.check_hostname = False
httpsserver = tornado.httpserver.HTTPServer(app, ssl_options=ssl_ctx)
httpsserver.add_sockets(https_sockets)
logger.info('starting https server on %s:%s' %
(bind_address, https_port))
ioloop = tornado.ioloop.IOLoop.current()
ioloop.start()
def register_database(app):
db = init_database(app)
with app.app_context():
db.create_all()
def init_database(self):
init_database(self.engine)
def tests_init_database_sql_alchemy(mocker):
sqlite3_mock = mocker.patch('models.sqlite3')
uri = "sqlite:///foo.db"
init_database(uri)
sqlite3_mock.connect.assert_called_once_with(database='foo.db')
def main():
init_database()
bot.run(settings.TOKEN)
def test_init_database_postgresql(uri, called_string, mocker):
psycopg2_mock = mocker.patch('models.psycopg2')
init_database(uri)
psycopg2_mock.connect.assert_called_once_with(called_string)
