def initialize_db(self):
db.initialize()
self.reminders = db.get_reminders()
if len(self.reminders):
self.active_reminder = random.choice(self.reminders)[1]
else:
self.active_reminder = 'No saved reminders. Try adding one now :)'
def initialize():
global initialized
if not initialized:
initialize_logger()
db.initialize()
initialize_worker_thread()
log.info("Initialize done!")
initialized = True
def login_page():
error = None
db.initialize()
if request.method == 'POST':
if request.form['username'] != 'admin' or request.form[
'password'] != 'admin':
error = 'Invalid Credentials. Please try again.'
else:
return redirect(url_for('home_page'))
return render_template('login.html', error=error)
def initialize(cls):
#call this function under same thread that invoke dispatch()
db.initialize()
cls.debug_con = utils.connect_debug_db()
cls.con = utils.connect_db()
cls.tables = [r[0] for r in cls.con.execute('select name from sqlite_master where type="table";')]
cls.table_cols = {t:get_cols(cls.con, t) for t in cls.tables}
def initialize(name):
os.chdir(str(conf.dir.run))
root = L.getLogger()
hdlr = L.FileHandler(str(conf['{}.log.path'.format(name)]))
fmt = L.Formatter(fmt=str(conf.log.format), datefmt=str(conf.log.datefmt))
root.setLevel(str(conf['{}.log.level'.format(name)]))
root.addHandler(hdlr)
hdlr.setFormatter(fmt)
db.initialize()
def initialize(options):
options["wwwroot"] = getAbsolutePath("../wwwroot")
options["port"] = int(sys.argv[1]) if len(
sys.argv) == 2 else options["port"]
options["databaseFile"] = getAbsolutePath('../lava-%s.db3' % (DB_VERSION))
print("Using database: %s" % options["databaseFile"])
if (os.path.isfile(options["databaseFile"]) == False):
options["connection"] = sqlite3.connect(options["databaseFile"])
print("Initializing New Database")
db.initialize(options["connection"])
else:
options["connection"] = sqlite3.connect(options["databaseFile"])
def register():
##try:
c, conn = initialize()
global cursor
global connect
cursor = c
connect = conn
##return("okay")
##except Exception as e:
##return (str(e))
if request.method == 'POST':
user = request.form['newusername']
output = createuser(user, c, conn)
'''r= requests.post('https://hunter-todo-api.herokuapp.com/user', json={'username':user})
text = json.loads(r.text)
print(text)'''
print(output)
if output == False:
return render_template('register.html')
else:
return redirect(url_for("login"))
else:
return render_template('register.html')
def setUp(self):
url = 'http://localhost:8080/tmis-ws-laboratory/tmis-laboratory-integration?wsdl'
self.client = Client(url, username='', password='', cache=None)
medipadWsUrl = 'http://localhost:8080/tmis-ws-medipad/tmis-medipad?wsdl'
self.medipadClient = Client(medipadWsUrl, username='', password='', cache=None)
# Authenticate
authenticator = Authenticator()
authData = authenticator.asAdmin()
# Add auth headers
tmisAuthNS = ('ta', 'http://korus.ru/tmis/auth')
authHeader = Element('tmisAuthToken', ns=tmisAuthNS).setText(authData.authToken.id)
self.medipadClient.set_options(soapheaders=authHeader)
db.initialize()
def article(category, article):
settings = extract_settings('categories.settings')
conn = db.initialize()
articles = db.db_Aquery(conn, 'ARTICLES')
db.deinitialize(conn)
for story in articles:
if articles[story][0] == article:
info = articles[story]
return render_template('article.html', category = category, article = article, info = info, settings = settings)
async def on_app_startup(app: web.Application):
"""
Defines the on-startup signal behavior for the application. The app parameter is
important for aiohttp's Signal interface.
:param app: The application instance the signal is being executed for.
"""
host = app["config"].get("server", "host")
port = app["config"].get("server", "port")
# Starting up...
app.logger.info("Starting up {{cookiecutter.app_name}} on address: {host}:{port}...".format(host=host, port=port))
# Initialize the database with the `get_current_request` function as the scoping function
# so that all SQLAlchemy DB sessions are created within the handler's current request context.
db.initialize(scope_function=get_current_request)
# Started!
app.logger.info("{{cookiecutter.app_name}} successfully started on {host}:{port}!".format(host=host, port=port))
def main():
logger.configure()
logger.log(logging.INFO,
msg="User started interacting with the scraper", destination=logger.FILE)
parser = argparse.ArgumentParser(description="scrape instagram by keyword (hashtag)")
# used only within cli mode
parser.add_argument("-k", "--keyword", help="the keyword to find in instagram (by hashtag or username)")
parser.add_argument("-l", "--limit", default=1000, help="limit of instagram posts to scrap")
parser.add_argument("-f", "--filename", help="option for logging in through a file\n"
"username must be in the first line and password in the second one")
args = parser.parse_args()
username, password, keyword = "", "", ""
# cli mode
if args.keyword:
keyword = args.keyword
filename = args.filename if args.filename else "auth.txt"
try:
username, password = get_auth_by_file(filename)
except FileNotFoundError:
logger.log(logging.ERROR,
msg="Neither the credentials file were provided nor the default auth.txt were found")
quit(0)
# interactive mode (default)
else:
username, password, keyword = interactive_credentials()
try:
# We initialize the DB
db.initialize()
# If all good we go scraping
scrape_data(username=username, password=password, keyword=keyword, limit=args.limit)
except FileNotFoundError:
print(f"You must have a file called {config.AUTH_DB_FILE} with your MySQL credentials: "
f"host, username and password each in a separate line.")
def register():
settings = extract_settings('categories.settings')
#construct months
months = list_generator(start_value = 0, count_value = 1)
#construct years
years = list_generator(start_value = datetime.datetime.now().year, max_count = 100)
#Main handler
if request.method == 'POST':
conn = db.initialize()
login_info = db.db_Aquery(conn, 'USERS')
db.deinitialize(conn)
if request.form['username'].strip() in login_info:
flash('Username already exists!')
return render_template('register.html', months=months, years = years)
else:
if request.form['password'] != '' and request.form['FirstName'] != '' and\
request.form['LastName'] != '' and request.form['Month'] != '' and\
request.form['Year'] != '':
#print('month', request.form['Month'])
#print('Year', request.form['Year'])
conn = db.initialize()
db.add_user(conn, request.form['FirstName'], request.form['MiddleName'], \
request.form['LastName'], request.form['Month'], request.form['Year'], \
request.form['username'].strip(), request.form['password'])
db.deinitialize(conn)
flash('Success')
session['logged_in'] = True
session['username'] = request.form['FirstName'].strip() + ' ' + request.form['LastName'].strip()
session['identifier'] = request.form['username'].strip()
return index()
else:
flash('Missing required fields!')
return render_template('register.html', months=months, years = years, settings = settings)
else:
return render_template('register.html', months=months, years = years, settings = settings)
def profile(username):
settings = extract_settings('categories.settings')
conn = db.initialize()
login_info = db.db_Aquery(conn, 'USERS')
db.deinitialize(conn)
if session['identifier'] in login_info:
email = session['identifier']
firstname = login_info[session['identifier']][1]
middlename = login_info[session['identifier']][2]
lastname = login_info[session['identifier']][3]
birthdate = str(login_info[session['identifier']][4]) + '/' + str(login_info[session['identifier']][5])
return render_template('profile.html', email = email, firstname = firstname, middlename = middlename,\
lastname = lastname, birthdate = birthdate, settings = settings)
def init_example():
_logger.info("[Init-Example] creating new database engine")
db.initialize()
# Check if the table exist
if not db.engine.dialect.has_table(db.engine, Example.__tablename__, db_option('schema')):
_logger.info("[Init-Example] creating new database table: `example`")
Example.__table__.create(bind=db.engine)
_logger.info("[Init-Example] creating new rows in table: `example`")
async def create_new_examples():
async with transactional_session() as session:
for i in range(1, 5):
session.add(Example(name=f"Example #{i}"))
session.commit()
asyncio.get_event_loop().run_until_complete(create_new_examples())
_logger.info("[Init-Example] cleaning up the database engine resources")
db.cleanup()
_logger.info("[Init-Example] done...")
def login():
settings = extract_settings('categories.settings')
if request.method == 'POST':
conn = db.initialize()
login_info = db.db_Aquery(conn, 'USERS')
db.deinitialize(conn)
if request.form['username'].strip() in login_info:
if request.form['password'] == login_info[request.form['username'].strip()][0]:
session['logged_in'] = True
session['username'] = login_info[request.form['username'].strip()][1] +\
' ' + login_info[request.form['username'].strip()][3]
session['identifier'] = request.form['username'].strip()
print(session['username'])
else:
flash('Login and/or Password is incorrect!')
return render_template('login.html', settings = settings)
else:
flash('Login and/or Password is incorrect!')
return render_template('login.html', settings = settings)
return index()
else:
return render_template('login.html', settings = settings)
import os
import flask
import psycopg2
import psycopg2.extras
from crossdomain import crossdomain
import db
app = flask.Flask(__name__)
db.initialize(os.getenv('DATABASE_URL', 'postgres://localhost'))
QUERY_RT = """
WITH stops_begin AS (
SELECT stop_id, stop_name, ST_Distance(
ST_Transform(ST_SetSRID(ST_MakePoint(%(start_lon)s, %(start_lat)s), 4326), 2163),
ST_Transform(ST_SetSRID(ST_MakePoint(stop_lon, stop_lat), 4326), 2163)
) AS distance
FROM stops
WHERE ST_Distance(
ST_Transform(ST_SetSRID(ST_MakePoint(%(start_lon)s, %(start_lat)s), 4326), 2163),
ST_Transform(ST_SetSRID(ST_MakePoint(stop_lon, stop_lat), 4326), 2163)
) < 800
), stops_end_choices AS (
SELECT stop_id
FROM stops
WHERE
ST_Distance(
def setUp(self):
self.conn = db.initialize('/tmp/sicksubs_test/test.db')
os.makedirs(interm)
os.makedirs(final)
os.system('touch ' + os.path.join(interm, 'White.Collar.S02E04.DVDRip.XviD-SAiNTS.avi'))
os.system('touch ' + os.path.join(final, 'White.Collar.S02E04.By.the.Book.avi '))
def articles():
settings = extract_settings('categories.settings')
conn = db.initialize()
articles = db.db_Aquery(conn, 'ARTICLES')
db.deinitialize(conn)
return render_template('articles.html', name = 'Articles', articles = articles, settings = settings)
def categories(category):
settings = extract_settings('categories.settings')
conn = db.initialize()
articles = db.db_Aquery(conn, 'ARTICLES', add_criteria = [category, 6])
db.deinitialize(conn)
return render_template('articles.html', name = category, articles = articles, settings = settings)
from datetime import timedelta
import db
import scorer
client = db.initialize()
def get_matched_players(event, line_ups):
matched_players_in_team_1 = [{
"team": line_ups["team_1"]["key_name"],
"player": item
} for item in line_ups["team_1"]["line_up"]
if item['key_name'].lower() in event.lower()]
matched_players_in_team_2 = [{
"team": line_ups["team_2"]["key_name"],
"player": item
} for item in line_ups["team_2"]["line_up"]
if item['key_name'].lower() in event.lower()]
return matched_players_in_team_1 + matched_players_in_team_2
def get_player_measurement(player, time, event):
return scorer.calculate_player(player, event, time)
def get_team_measurement(line_up, time, event):
team_1 = line_up['team_1']
team_2 = line_up['team_2']
return scorer.calculate_team(team_1, team_2, event, time)
import discord, traceback
from datetime import datetime, timezone
import censor, commands, config, db, visualize
import commonbot.utils
from censor import check_censor
from config import client, LogTypes
from spam import Spammers
from tattletale import check_tattletale
from waiting import AnsweringMachineEntry
from watcher import Watcher
from commonbot.debug import Debug
from commonbot.timekeep import Timekeeper
# Initialize helper classes
db.initialize()
dbg = Debug(config.OWNER, config.CMD_PREFIX, config.DEBUG_BOT)
spam = Spammers()
tk = Timekeeper()
watch = Watcher()
FUNC_DICT = {
"ban": [commands.logUser, LogTypes.BAN],
"block": [commands.blockUser, True],
"censor": [censor.listCensor, None],
"clear": [commands.am.clear_entries, None],
"edit": [commands.removeError, True],
"graph": [visualize.post_plots, None],
"help": [commands.send_help_mes, None],
"kick": [commands.logUser, LogTypes.KICK],
"note": [commands.logUser, LogTypes.NOTE],
print e
return False
return True
def update_tvdbids(sids, tvdbid):
if tvdbid not in sids:
sid = bierdopje.get_show_id(tvdbid)
sids[tvdbid] = sid
return sids
if __name__ == '__main__':
if '-q' in sys.argv:
quiet = True
sys.argv.remove('-q')
if len(sys.argv) == 2:
db_path = sys.argv[2]
else:
db_path = DATABASE_FILE
if not os.path.exists(db_path):
conn = db.initialize(db_path)
else:
conn = sqlite3.connect(db_path)
if len(sys.argv) == 7:
sickbeard_run(conn)
else:
cron_run(conn)
successful = []
for d in to_download:
if subdl.attemptDownloadSubtitle(to_download[d], [SUB_LANG]) is not None:
successful.append(d)
# remove successfully downloaded files from db
db.remove_downloaded(conn, successful)
# call post-processing for successfully downloaded files
if POST_CALL:
for d in successful:
for script in POST_CALL.split(","):
to_call = shlex.split(script)
to_call.append(d.final_loc)
subprocess.call(to_call)
if __name__ == "__main__":
if "-q" in sys.argv:
quiet = True
sys.argv.remove("-q")
if not os.path.exists(DATABASE_FILE):
conn = db.initialize(DATABASE_FILE)
else:
conn = sqlite3.connect(DATABASE_FILE)
if len(sys.argv) in (2, 7):
sickbeard_run(conn)
else:
cron_run(conn)
def initialize_db():
initialize()
# -*- coding: utf-8 -*-
"""
This module is a part fo OnlinePython project created at DTU
for the course Data Mining Using Python.
This is the main module that initializes and starts up the whole program.
Created on Sun Oct 5 19:09:58 2014
@author: Bartosz
"""
#Own created modules
import db
import web
if __name__ == '__main__':
db.initialize()
web.initialize()
app.config['IMG_FOLDER'] = './static/img'
"""Clave necesaria para poder utilizar flash"""
app.secret_key = 'clave_secreta'
#Conexion a la bd
db = connect_db()
#Borrar coleccion
#db.heroes.drop()
#Checkear que haya datos en la bd
collist = db.list_collection_names()
if "heroes" not in collist:
#cargar datos
initialize(db)
@app.route('/', methods=['GET'])
def get_heroes():
#Obtener heroes de ambas casas
data = db.heroes.find().sort('name')
#Convertir BSON a JSON
data = json_util.dumps(data)
#json list
data = json_util.loads(data)
return render_template('home.html', data=data)
@app.route('/marvel', methods=['GET'])
def get_heroes_marvel():
#Obtener heroes de marvel
