def start(self):
initialize_database(DB_FILE)
s = gevent.spawn(self.run_forever)
self.connect()
self.dispatcher_loop()
self.receiver_loop()
self.probe_users()
self.process_users()
s.join()
def main():
# We create an argument parser
arg_parser = arguments.create_argument_parser()
# We parse the arguments
args = arg_parser.parse_args(sys.argv[1:])
arguments.process_arguments(args, arg_parser)
# If the verbose mode is on, we display the arguments
if args.verbose:
arguments.print_arguments(args)
# We open the database file where the proxies will be stored
connection, cursor = database.initialize_database(args.database_file)
try:
# We generate the proxies
for proxy in parser.generate_proxy(args):
# And we store them in the database
database.insert_in_database(cursor, proxy)
except KeyboardInterrupt:
if args.verbose:
print('')
print('[warn] received interruption signal')
# We save the changes made to the database, and close the file
connection.commit()
connection.close()
return 0
def main():
# We create an argument parser
arg_parser = arguments.create_argument_parser()
# We parse the arguments
args = arg_parser.parse_args(sys.argv[1:])
arguments.process_arguments(args, arg_parser)
# If the verbose mode is on, we display the arguments
if args.verbose:
arguments.print_arguments(args)
# We open the database file where the proxies will be stored
connection, cursor = database.initialize_database(args.database_file)
try:
# We generate the proxies
for proxy in parser.generate_proxy(args):
# And we store them in the database
database.insert_in_database(cursor, proxy)
except KeyboardInterrupt:
if args.verbose:
print('')
print('[warn] received interruption signal')
# We save the changes made to the database, and close the file
connection.commit()
connection.close()
return 0
def setUpClass(self):
settings = TestingConfig.get_database_from_url(TestingConfig.DATABASE_URL)
self.db = initialize_database(settings)
self.cache = fakeredis.FakeStrictRedis()
self.cache.set('bov-eod-scrapper:last_update', dt(2016, 04, 10))
sql_file = os.path.join(os.path.abspath(os.path.dirname(__file__))) + '/res/setup_test_database.sql'
drop_database(self.db)
run_sql_file(sql_file, self.db)
def main(target_dir: Path):
logging.info("Initializing database.")
initialize_database()
logging.info(f"Collecting photos and sub-directories of \"{target_dir}\".")
collections = scan(str(target_dir))
session = get_session()
for collection in collections:
collection_record = stage_collection_in_database(collection, session)
stage_images_in_database(collection.images, collection_record, session)
logging.info(
f"{collection.name} : {len(collection.images)} : {collection.path}"
)
logging.info("Adding new items to database.")
session.flush()
session.commit()
logging.info("Complete.")
def main():
# We create an argument parser
arg_parser = arguments.create_argument_parser()
# We parse the arguments
args = arg_parser.parse_args(sys.argv[1:])
arguments.process_arguments(args, arg_parser)
# If the verbose mode is on, we display the arguments
if args.verbose:
arguments.print_arguments(args)
if args.database_file is not None and args.text_file is None:
# We open the database file where the proxies will be stored
connection, cursor = database.initialize_database(args.database_file)
try:
# We generate the proxies
for proxy in parser.generate_proxy(args):
# And we store them in the database
database.insert_in_database(cursor, proxy)
except KeyboardInterrupt:
if args.verbose:
print('')
print('[warn] received interruption signal')
# We save the changes made to the database, and close the file
connection.commit()
connection.close()
return 0
# Write to text file with priority
elif args.text_file is not None or args.text_file is not None and args.database_file is not None:
with open(args.text_file, 'w') as tf:
for proxy in parser.generate_proxy(args):
proxy_line = proxy[2].lower() + '://' + str(
proxy[0]) + ':' + str(proxy[1]) + '\n'
tf.write(proxy_line)
elif args.database_file is None and args.text_file is None:
return 'Please specify output file!'
def menu():
connection = database.initialize_database()
while (user_option := input(MENU_PROMPT)) != '5':
if user_option == '1':
enter_seed_information(connection)
elif user_option == '2':
seeds = database.get_seed_info(connection)
for seed in seeds:
print(seed)
elif user_option == '3':
name = input('Enter Seed Name:')
seeds = database.get_seed_info_by_name(connection, name)
for seed in seeds:
print(seed)
elif user_option == '4':
seed_type = input('Enter Seed Type:')
seeds = database.get_seed_info_by_type(connection, seed_type)
for seed in seeds:
print(seed)
else:
print('Invalid Option, try again!!!')
def store_last_update(end_date):
last_update = dt.strftime(end_date, DATE_FORMAT)
filename.write(last_update)
filename.flush()
filename.close()
def update_database():
"""
Method called to update the database.
"""
update = Update()
last_update = load_last_update()
from_date = last_update + td(days=1)
end_date = dt.now()
update.update_daily_data(from_date, end_date)
store_last_update(end_date)
logger.info('Database EOD has been updated.')
if __name__ == '__main__':
config = ProductionConfig()
logger.info('Start update database...')
logger.info('Config type: {type}'.format(type=config.CONFIG_TYPE))
logger.info('Database URL : {url}'.format(url=config.DATABASE_URL))
settings = config.get_database_from_url(config.DATABASE_URL)
initialize_database(settings)
update_database()
def create_app():
app = Flask(__name__)
@app.route("/")
def index():
return render_template("index.html")
@app.route("/api/all")
def request_all_countries():
""" get information about all countries """
update_data()
year_start = int(request.args.get("start", 0) or 0)
year_end = int(request.args.get("end", 0) or 0)
per_capita = bool(request.args.get("percapita", None))
data = database.get_all_countries_data(year_start, year_end, per_capita)
data_by_code = {}
for code, year, value in data:
if code not in data_by_code:
data_by_code[code] = []
data_by_code[code].append((year, value))
return jsonify(data_by_code)
@app.route("/api/country/<country_code>")
def request_one_country(country_code):
""" get information about a single country """
update_data()
year_start = int(request.args.get("start", 0) or 0)
year_end = int(request.args.get("end", 0) or 0)
per_capita = bool(request.args.get("percapita", None))
data = database.get_one_country_data(
country_code, year_start, year_end, per_capita
)
data_by_code = {data[0][0]: []}
for code, year, value in data:
data_by_code[code].append((year, value))
return jsonify(data_by_code)
@app.route("/api/meta/all")
def request_country_metadata():
""" get metadata of all countries """
update_data()
metadata = database.get_countries_info()
response_data = {
code: {"name": name, "region": region, "income": income, "notes": notes}
for name, code, region, income, notes in metadata
}
return jsonify(response_data)
database.initialize_database()
update_data(force=True)
return app
runmode = sys.argv[1]
if runmode == "sc": # set the number of VNFs to chain
num_VNFs = int(sys.argv[2])
elif runmode == "case": # measure a specific service chain
list_VNFs = sys.argv[2]
else:
print "%s { vnf | sc [# of VNFs] | case [list of VNFs(,)] }" % sys.argv[
0]
exit(0)
else:
print "%s { vnf | sc [# of VNFs] | case [list of VNFs(,)] }" % sys.argv[
0]
exit(0)
# initialize database
database.initialize_database()
print "Initialized the Probius database"
if vnf_mgmt.is_athene_env() == True: # Athene
# load analysis configurations
analysis = load_analysis_configurations("config/analysis_athene.conf")
print "Loaded analysis configurations"
# load VNF configurations
config = vnf_mgmt.load_VNF_configurations("config/vnf_athene.conf")
print "Loaded VNF configurations"
# update VNF configurations
config = vnf_mgmt.update_VNF_configurations(config)
print "Updated VNF configurations"
def load_database():
initialize_database(app.config["DB_URL"])
users = db.get_users(cursor)
messages = jobs.generate_update_message(updates)
for user in users:
if user[1] in messages.keys():
try:
context.bot.send_message(chat_id=user[0],
text=messages[user[1]])
except telegram.error.Unauthorized:
with db.connection() as cursor:
db.delete_user(cursor, user[0])
if __name__ == "__main__":
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
level=logging.INFO,
)
db.initialize_database()
updater = Updater(token=API)
dispatcher = updater.dispatcher
add_handlers()
updater.start_polling()
updater.job_queue.run_daily(update_job, time(hour=9, minute=30))
updater.idle()
f"All update done. Result can be found in table {pistoncup.__table__.name}."
)
session.close()
if __name__ == '__main__':
# Download, extract and save the data files to disk
utils.mkdir(directory=constants.DATA_FOLDER)
for file in constants.FILES:
download_and_save_gzip_from_url(source=file,
destination=constants.DATA_FOLDER)
# initialize objects to talk to database
engine = utils.get_db_engine()
if not database.is_initialized(engine):
database.initialize_database(engine)
if not check_db_filled(engine):
vehicle_table = database.Vehicle
mater_table = database.Mater
# Read csv files into lists
mater: List[List[str]] = list()
vehicles: List[List[str]] = list()
for file in os.listdir(constants.DATA_FOLDER):
file_vehicle_list = read_data_from_csv(
source=os.path.join(constants.DATA_FOLDER, file))
mater, vehicles = split_into_long_and_normal_lists(
file_vehicle_list, mater, vehicles)
# Load data lists into database tables
import os import errno import hashlib from Queue import Empty as QueueEmptyException from multiprocessing import Process, Queue from scidb_server_interface import D3_DATA_THRESHOLD from cache_worker_functions import compute_tile, print_tile_params, compute_first_tile, list_all_tiles, get_tile_counts, TileMetadata import database as db import json from time import sleep DEBUG = True cache_root_dir = '_scalar_cache_dir2' uri = 'postgresql+psycopg2://testuser:password@localhost:5432/test' db.initialize_database(uri) queries = ["select * from cali100"] # list of dataset names data_thresholds = [D3_DATA_THRESHOLD] # list of thresholds (ints) QUEUE_MARKER = "END" sleeptime = 20 maxpool = 2 # hashes a string def hash_it(s): h = hashlib.md5() h.update(str(s)) return h.hexdigest()
def init():
return initialize_database(app.config['dsn'])