def load():
DB.initialize()
loadFromXML()
loadFromDB()
util.DEBUG_LOG('Rating Systems:')
for rs in RATINGS_SYSTEMS.values():
util.DEBUG_LOG(' {0}'.format(repr(rs)))
def load():
DB.initialize()
loadFromXML()
loadFromDB()
util.DEBUG_LOG('Rating Systems:')
for rs in RATINGS_SYSTEMS.values():
util.DEBUG_LOG(' {0}'.format(repr(rs)))
def DBChoices(self, attr):
import database as DB
DB.initialize()
DB.connect()
try:
return [(x.path, os.path.basename(x.path)) for x in DB.VideoBumpers.select().where(DB.VideoBumpers.type == self.vtype)]
finally:
DB.close()
def DBChoices(self, attr):
import database as DB
DB.initialize()
DB.connect()
try:
return [(x.path, os.path.basename(x.path)) for x in DB.VideoBumpers.select().where(DB.VideoBumpers.type == self.vtype)]
finally:
DB.close()
def main(init_database, number_workers):
if init_database:
if click.confirm(
'Are you sure to initialize the database? This will clear the database if exists!'
):
initialize()
else:
print('Aborted.')
else:
run_pipeline(number_workers)
def test_bulk_operations(database_test_file, nodes, edges):
db.initialize(database_test_file)
ids = []
bodies = []
for id, body in nodes.items():
ids.append(id)
bodies.append(body)
# bulk add and confirm
db.atomic(database_test_file, db.add_nodes(bodies, ids))
for id, node in nodes.items():
assert db.atomic(database_test_file, db.find_node(id)) == node
# bulk upsert and confirm
db.atomic(database_test_file, db.upsert_nodes(bodies, ids))
for id, node in nodes.items():
assert db.atomic(database_test_file, db.find_node(id)) == node
# bulk connect and confirm
sources = []
targets = []
properties = []
for src, tgts in edges.items():
for target in tgts:
tgt, label = target
sources.append(src)
targets.append(tgt)
if label:
properties.append(label)
else:
properties.append({})
db.atomic(database_test_file,
db.connect_many_nodes(sources, targets, properties))
for src, tgts in edges.items():
actual = [
tuple(x)
for x in [[edge[0], edge[1], json.loads(edge[2])]
for edge in db.atomic(database_test_file,
db.get_connections_one_way(src))]
]
for target in tgts:
tgt, label = target
if label:
expected = (str(src), str(tgt), label)
else:
expected = (str(src), str(tgt), {})
assert expected in actual
# bulk remove and confirm
db.atomic(database_test_file, db.remove_nodes(ids))
for id in ids:
assert db.atomic(database_test_file, db.find_node(id)) == {}
def main():
database.initialize()
bot = LulzBot()
bot.connection.set_keepalive(300)
connected = False
while not connected:
try:
bot.start()
except irc.client.ServerConnectionError:
time.sleep(60)
else:
connected = True
def main():
database.initialize()
bot = LulzBot()
bot.connection.set_keepalive(300)
connected = False
while not connected:
try:
bot.start()
except irc.client.ServerConnectionError:
time.sleep(60)
else:
connected = True
def __init__(self, sequence_path, db_path=None, content_path=None):
DB.initialize(db_path)
self.pos = -1
self.size = 0
self.sequence = []
self.featureQueue = []
self.playables = []
self.genres = []
self.contentPath = content_path
self.lastFeature = None
self._lastAction = None
self.loadSequence(sequence_path)
self.createDefaultFeature()
def DBChoices(attr):
import database as DB
DB.initialize()
ratingSystem = util.getSettingDefault('rating.system.default')
DB.connect()
try:
return [
(x.style, x.style) for x in DB.RatingsBumpers.select(DB.fn.Distinct(DB.RatingsBumpers.style)).where(DB.RatingsBumpers.system == ratingSystem)
]
finally:
DB.close()
def DBChoices(attr):
import database as DB
DB.initialize()
ratingSystem = util.getSettingDefault('rating.system.default')
DB.connect()
try:
return [(x.style, x.style) for x in DB.RatingsBumpers.select(
DB.fn.Distinct(DB.RatingsBumpers.style)).where(
DB.RatingsBumpers.system == ratingSystem)]
finally:
DB.close()
def __init__(self, sequence_path, db_path=None, content_path=None):
DB.initialize(db_path)
self.pos = -1
self.size = 0
self.sequence = []
self.featureQueue = []
self.playables = []
self.genres = []
self.contentPath = content_path
self.lastFeature = None
self._lastAction = None
self.loadSequence(sequence_path)
self.createDefaultFeature()
def apple(database_test_file, nodes, edges):
db.initialize(database_test_file)
[
db.atomic(database_test_file, db.add_node(node, id))
for id, node in nodes.items()
]
for src, targets in edges.items():
for target in targets:
tgt, label = target
if label:
db.atomic(database_test_file,
db.connect_nodes(src, tgt, label))
else:
db.atomic(database_test_file, db.connect_nodes(src, tgt))
yield
def update():
print('Initializing database...')
database.initialize()
print('Getting available terms...')
terms = scrape.getTerms()
print('Terms retrieved. Updating table...')
database.insert('terms', terms)
print('Getting faculty information and dates for available terms...')
termsInfo = {
'faculties' : [],
'dates' : []
}
for term in terms:
termInfo = scrape.getFacultiesAndDates(term['id'])
termsInfo['faculties'].extend(termInfo['faculties'])
termsInfo['dates'].extend(termInfo['dates'])
print('Faculties and dates retrieved. Updating tables...')
database.insert('faculties', termsInfo['faculties'])
database.insert('dates', termsInfo['dates'])
print('Checking the database for new stats to retrieve...')
missingStats = database.getMissingEmploymentStats()
count = len(missingStats)
print('{count} records to retrieve. Starting retrieval...'.format(count=count))
employment = []
termsMap = processTerms(database.getTerms())
facultiesMap = {}
for termKey in termsMap:
facultiesMap[termKey] = processFaculties(database.getFaculties(termKey))
current = 1
for entry in missingStats:
delay = random.random()*.5
time.sleep(delay)
print('({percent:5.2f}%):{current}/{count} - Fetching info on {faculty} from {date} in {term}...'.format(percent=float(current)/count * 100, current=current, count=count, faculty=facultiesMap[entry[0]][entry[2]], date=str(entry[1]), term=termsMap[entry[0]]))
employment.extend(scrape.getEmploymentStats(*entry))
if current % 25 == 0:
print('Saving new entries...')
database.insert('employment', employment)
employment = []
current+=1
database.insert('employment', employment)
print('Update complete.')
def execute():
warnings.filterwarnings("ignore")
initialize_logging("../logs/merge.log", "a+")
logger = logging.getLogger()
engine, session = database.initialize("sqlite:///../data/isrid-master.db")
with open("../data/mappings.yaml") as mappings_file:
mappings = yaml.load(mappings_file.read())
for filename in os.listdir("../data/"):
if filename.endswith(".xlsx"):
for title, rows in read_excel(os.path.join("../data/", filename)):
procedure = Registry.retrieve(filename, title)
procedure = procedure or Registry.retrieve(filename)
mapping = mappings.get(filename, {}).get(title, {})
if procedure:
message = "Merging '{}' from '{}' ... "
logger.info(message.format(title, filename))
labels = list(next(rows))
if labels.count("Equipment4") > 1:
index = labels[::-1].index("Equipment4")
labels[-index - 1] = "Equipment5"
for index, row in enumerate(rows):
labeled_row = dict(zip(labels, row))
for model in procedure(index, labeled_row, mapping):
session.add(model)
session.commit()
logging.shutdown()
database.terminate(engine, session)
def read_time_data(url):
"""
Read the time of day each incident occurred at.
Arguments:
url: A string representing the path to the database.
Returns:
A `pandas` dataframe with two columns: `time` and `hour`. `time`
contains Python `datetime.time` objects with times at midnight filtered
out (most of these indicate a date was available, but not time). `hour`
is `time` in hours (a float between 0 and 24, exclusive).
`time` is derived from `Incident.datetime`.
"""
engine, session = database.initialize(url)
df = tabulate(session.query(Incident.datetime))
database.terminate(engine, session)
df = df.assign(time=[datetime.time() for datetime in df.datetime])
df = df[df.time != datetime.time(0)]
df = df.assign(hour=[time.hour + time.minute/60 + time.second/3600
for time in df.time])
return df
def main():
"""
Bootstrap the update process by wrapping the initialization and termination
of logging and database access.
Errors raised by tasks are caught here and logged, and the script is
immediately killed.
"""
initialize_logging('../logs/update.log')
logger = logging.getLogger()
engine, session = database.initialize('sqlite:///../data/isrid-master.db')
tasks = [augment_weather_instances]
for task in tasks:
try:
task_name = task.__name__.replace('_', ' ')
logger.info('Starting task: {}'.format(task_name))
task(session)
except KeyboardInterrupt:
print()
logger.info('Terminating update ... ')
break
except Exception as error:
logger.error('{}: {}'.format(type(error).__name__, error))
break
logging.shutdown() # Flush files
database.terminate(engine, session)
def setUp(self):
self.engine, self.session = database.initialize('sqlite:///:memory:')
self.group = Group()
self.subject = Subject(sex='female', weight=25, height=100,
group=self.group)
self.location = Location()
self.weather = Weather()
self.operation = Operation()
self.outcome = Outcome()
self.search = Search()
self.incident = Incident(source='US-CAm', group=self.group,
location=self.location, weather=self.weather,
operation=self.operation,
outcome=self.outcome, search=self.search)
instances = [self.group, self.subject, self.location, self.weather,
self.operation, self.outcome, self.search, self.incident]
for instance in instances:
self.session.add(instance)
self.session.commit()
def load(data):
''' Insert or update data in the target database '''
db_engine = database.initialize()
db_session = sessionmaker(bind=db_engine)()
generator_data = (database.models.Caged(**caged) for caged in data)
for caged in tqdm(generator_data, total=len(data)):
db_session.merge(caged)
db_session.commit()
def main():
# Initialize Selenium
driver = Chrome()
driver.implicitly_wait(15)
# Initialize database
session = Db.initialize()
# Login to LinkedIn
login.to_linkedin(driver)
login.to_Salesforce(driver)
# Get list of persons
persons = get_persons_linkedin(driver, os.getenv('ACCOUNT_PAGE'))
# Scrape persons
for i in range(len(persons)):
url = persons[i]['url']
try:
person = get_profile_linkedin(driver, url)
Db.add_person(session, person)
except Exception:
pass
Db.update_first_and_last(session)
# Fetch all rows from database
rows = Db.fetch_all(session, Db.Person)
# Iterate over records and update title
for row in rows:
title = get_title(driver, row.linkedin_url)
stmt = (update(
Db.Person).where(Db.Person.id == row.id).values(job_title=title))
stmt.execute()
# Read duplicates, LinkedIn URLs as csv
dupes = Db.read_csv_file_as_list('./dupes.csv')
# Create contacts in Salesoforce
for c in rows:
if [c['linkedin_url']] not in dupes:
sf.create_contact(driver,
account_id=os.getenv('ACCOUNT_ID'),
first=c['first'],
last=c['last'],
title=c['job_title'],
url=c['linkedin_url'],
city=c['location'],
about=c['about'],
phone='123')
sf.log_a_call(driver, None, 'LinkedIn connect',
'Requested to connect', 'L')
# Connect on LinkedIn
for c in rows:
# Connect on LinkedIn
linkedin.connect_on_linkedin(driver, c['linkedin_url'])
def read_data(url):
engine, session = database.initialize(url)
query = session.query(Incident.total_hours, Subject.survived,
Group.category).join(Group, Subject)
df = tabulate(query)
database.terminate(engine, session)
return df
def read_time_data(url):
engine, session = database.initialize(url)
df = tabulate(session.query(Incident.datetime))
database.terminate(engine, session)
df = df.assign(time=[datetime.time() for datetime in df.datetime])
df = df[df.time != datetime.time(0)]
df = df.assign(hour=[time.hour + time.minute/60 + time.second/3600
for time in df.time])
return df
def setUp(self):
self.engine, self.session = database.initialize('sqlite:///:memory:')
for age in range(1, 11):
status = 'DOA' if random.random() < 0.5 else 'Well'
subject = Subject(age=age, status=status)
if age < 6:
subject.weight = 20
self.session.add(subject)
self.session.commit()
def start_gui():
import wx
import gui.mainBoard as mainWindow
#---------------------------------------------------------------------------
class MyApp(wx.App):
def OnInit(self):
self.SetAppName('MALODOS')
#if len(sys.argv)>1 and os.path.exists(sys.argv[1]): database.theBase.use_base(sys.argv[1])
self.frame = mainWindow.MainFrame(None, 'MALODOS')
self.frame.Show(True)
self.SetTopWindow(self.frame)
#if str_to_bool(database.theConfig.get_param('encryption', 'encryptData','False',True)): get_current_password()
#if not database.theBase.buildDB():
# return False
return True
app = MyApp(False)
database.initialize()
app.frame.initialize()
#if not database.theBase.buildDB(): raise 'Unable to load the database'
app.MainLoop()
def setUp(self):
self.engine, self.session = database.initialize('sqlite:///:memory:')
self.subjects = [Subject() for number in range(10)]
self.ipp = Point(latitude=0, longitude=0)
self.group = Group(subjects=self.subjects)
self.operation = Operation(ipp=self.ipp)
self.incident = Incident(group=self.group, operation=self.operation)
instances = [self.ipp, self.group, self.operation, self.incident]
for instance in self.subjects + instances:
self.session.add(instance)
self.session.commit()
def read_simple_data(url, exclude_singles=False, exclude_groups=False):
"""
Read incident duration, survival, and category data. A useful shorthand.
Arguments:
url: A string representing the database URL to connect to.
exclude_singles: A boolean indicating whether the query should exclude
subjects from groups with exactly one member.
exclude_groups: A boolean indicating whether the query should exclude
subjects from groups with more than one members.
Returns:
A pandas dataframe containing the lost person data. The columns include
`total_hours`, `survived`, `category`, `days` (the incident duration in
days, as taken from `total_hours`), and `doa` (a boolean that is `True`
is the subject did not survive). Cases with a negative timedelta
`Incident.total_hours` are filtered out.
Warning:
If `exclude_singles` is `True` or `exclude_groups` is `True`, the
function also needs to query the size of each `Group`, which may take
a while (perhaps a minute).
"""
engine, session = database.initialize(url)
columns = Incident.total_hours, Subject.survived, Group.category, Group.id
query = session.query(*columns).join(Group, Subject)
df = tabulate(query)
database.terminate(engine, session)
if exclude_singles or exclude_groups:
df['size'] = [Group.query.get(int(id_)).size for id_ in df.id] # Hack
if exclude_singles:
df = df[df['size'] > 1]
if exclude_groups:
df = df[df['size'] == 1]
if 'size' in df:
df.drop('size', 1, inplace=True)
df.drop('id', 1, inplace=True)
df = df.assign(days=[total_hours.total_seconds()/3600/24
for total_hours in df.total_hours],
doa=[not survived for survived in df.survived])
df = df[0 <= df.days]
return df
def read_data(url, *columns, not_null=True):
engine, session = database.initialize(url)
query = session.query(*columns).join(Group, Incident)
query = query.filter(*map(lambda column: column != None, columns))
database.terminate(engine, session)
data = pd.DataFrame()
for column in columns:
name, datatype = str(column).split(".")[-1], column.type.python_type
values = (value for value, *empty in query.from_self(column))
if datatype == datetime.timedelta:
datatype = float
values = map(lambda value: value.total_seconds() / 3600, values)
data[name] = np.fromiter(values, np.dtype(datatype))
return data
def loop():
"""
Read and evaluate expressions provided by the user.
"""
engine, session = database.initialize('sqlite:///../data/isrid-master.db')
print('Shell initialized at: {}'.format(datetime.datetime.now()))
cmd = 1 # You can change your prompt to include the command number
while True:
try:
expression = input('[!] ').strip()
if len(expression) == 0:
continue
print(' =>', eval(expression))
except (KeyboardInterrupt, EOFError):
print()
break
except Exception as error:
print(' => {}: {}'.format(type(error).__name__, error))
finally:
cmd += 1
database.terminate(engine, session) # Cleanly shut down SQLAlchemy
def execute():
initialize_logging('../logs/update.log')
logger = logging.getLogger()
engine, session = database.initialize('sqlite:///../data/isrid-master.db')
tasks = [augment_weather_instances]
for task in tasks:
try:
task_name = task.__name__.replace('_', ' ')
logger.info('Starting task: {}'.format(task_name))
task(session)
except KeyboardInterrupt:
print()
logger.info('Terminating update ... ')
break
except Exception as error:
logger.error('{}: {}'.format(type(error).__name__, error))
break
logging.shutdown()
database.terminate(engine, session)
def initialize_session(url='sqlite:///../data/isrid-master.db'):
if not database_initialized():
app.logger.info('Database initialized')
g.engine, g.session = database.initialize(url)
def execute():
matplotlib.rc("font", size=20)
engine, session = database.initialize("sqlite:///../data/isrid-master.db")
# Query with Group.size may take awhile, at least for Charles
# Not sure why
query = session.query(Incident.total_hours, Subject.survived, Group.category, Group.size).join(Group, Subject)
print("Tabulating query... may take awhile for unknown reasons.")
df = tabulate(query)
print("Done tabulating.")
print(df.describe())
database.terminate(engine, session)
df = df.assign(
days=[total_hours.total_seconds() / 3600 / 24 for total_hours in df.total_hours],
doa=[not survived for survived in df.survived],
)
df = df[0 <= df.days]
rows, columns = 2, 2
grid, axes = plt.subplots(rows, columns, figsize=(15, 10))
categories = Counter(df.category)
plot = 0
kmfs = []
options = {"show_censors": True, "censor_styles": {"marker": "|", "ms": 6}, "censor_ci_force_lines": False}
for category, count in categories.most_common()[: rows * columns]:
print("Category:", category)
ax = axes[plot // columns, plot % columns]
df_ = df[df.category == category]
N, Ndoa = len(df_), sum(df_.doa)
Srate = 100 * (1 - Ndoa / N)
grp = df_[df_.size > 1]
sng = df_[df_.size == 1]
kmf = KaplanMeierFitter()
# kmf.fit(df_.days, event_observed=df_.doa, label=category)
# kmf.plot(ax=ax, ci_force_lines=True)
kmf.fit(grp.days, event_observed=grp.doa, label=category + " Groups")
kmf.plot(ax=ax, **options)
kmf.fit(sng.days, event_observed=sng.doa, label=category + " Singles")
kmf.plot(ax=ax, **options)
kmfs.append(kmf)
ax.set_xlim(0, min(30, 1.05 * ax.get_xlim()[1]))
ax.set_ylim(0, 1)
ax.set_title("{}, N = {}, DOA = {}, {:.0f}% surv".format(category, N, Ndoa, Srate))
ax.set_xlabel("Total Incident Time (days)")
ax.set_ylabel("Probability of Survival")
# ax.legend_.remove()
# ax.grid(True)
plot += 1
grid.suptitle("Kaplan-Meier Survival Curves", fontsize=25)
grid.tight_layout()
grid.subplots_adjust(top=0.9)
grid.savefig("../doc/figures/kaplan-meier/km-grid-large.svg", transparent=True)
combined = plt.figure(figsize=(15, 10))
ax = combined.add_subplot(1, 1, 1)
for kmf in kmfs[: rows * columns]:
kmf.plot(ci_show=False, show_censors=True, censor_styles={"marker": "|", "ms": 6}, ax=ax)
ax.set_xlim(0, 15)
ax.set_ylim(0, 1)
ax.set_xlabel("Total Incident Time (days)")
ax.set_ylabel("Probability of Survival")
ax.set_title("Kaplan-Meier Survival Curves", fontsize=25)
ax.grid(True)
combined.savefig("../doc/figures/kaplan-meier/km-combined-large.svg", transparent=True)
plt.show()
from flask import Flask, request, jsonify
from flask_cors import CORS
from database import initialize, Question, User, Response, Config
from typing import Dict, List
DATABASE_URI = "sqlite:///quiz.db"
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URI
CORS(app)
db = initialize(app)
class APIError(Exception):
status_code = 400
def __init__(self, message, status_code=None, payload=None):
Exception.__init__(self)
self.message = message
if status_code is not None:
self.status_code = status_code
self.payload = payload
def to_dict(self):
rv = dict(self.payload or ())
rv["message"] = self.message
return rv
@app.errorhandler(APIError)
import os
from flask import Flask, request, redirect, jsonify
from dotenv import load_dotenv
from spotify import get_spotify_url, save_user, get_all_user_playing
from database import initialize, retrieve_last_songs
from scheduler import start_scheduler
load_dotenv()
app = Flask(__name__)
initialize()
@app.route("/")
def home():
return "Maronn!"
@app.route("/authorize")
def authorize():
return redirect(get_spotify_url("test"))
@app.route("/callback")
def callback():
user_code = request.args.get("code")
save_user(user_code)
return redirect("/")
@app.route("/playing")
def setUp(self):
url = 'sqlite:///../data/isrid-master.db'
self.engine, self.session = database.initialize(url)
def main():
""" Zarp entry point
"""
# set up configuration
config.initialize()
# set up database
database.initialize()
# load modules
loader = LoadedModules()
loader.load()
util.Msg('Loaded %d modules.' % loader.total)
# handle command line options first
if len(argv) > 1:
parse_cmd.parse(argv, loader)
# menus
main_menu = [
'Poisoners', 'DoS Attacks', 'Sniffers', 'Scanners', 'Parameter',
'Services', 'Attacks', 'Sessions'
]
running = True
choice = -1
while running:
util.header()
choice = util.print_menu(main_menu)
if choice == 0:
# check if they've got running sessions!
cnt = stream.get_session_count()
if cnt > 0:
display = color.B_YELLOW + 'You have %d sessions running. ' + \
'Are you sure? ' + color.B_GREEN + '[' + color.B_YELLOW + \
'Y' + color.B_GREEN + '/' + color.B_YELLOW + 'n' + \
color.B_GREEN + '] ' + color.END
choice = raw_input(display % cnt)
if 'y' in choice.lower() or choice == '':
util.Msg('Shutting all sessions down...')
stream.stop_session('all', -1)
running = False
else:
util.debug("Exiting with session count: %d" % (cnt))
util.Msg("Exiting...")
running = False
# remove zarp temporary directory
util.init_app('rm -fr /tmp/.zarp/')
# recheck that all sessions are down
cnt = stream.get_session_count()
if cnt <= 0:
# some libs dont clean up their own threads, so
# we need to hard quit those to avoid hanging; FIXME
_exit(1)
elif choice == 1:
while True:
choice = util.print_menu([x().which for x in loader.poison])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.poison):
continue
else:
stream.initialize(loader.poison[choice - 1])
elif choice == 2:
while True:
choice = util.print_menu([x().which for x in loader.dos])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.dos):
continue
else:
stream.initialize(loader.dos[choice - 1])
elif choice == 3:
while True:
choice = util.print_menu([x().which for x in loader.sniffers])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.sniffers):
continue
else:
stream.initialize(loader.sniffers[choice - 1])
elif choice == 4:
while True:
choice = util.print_menu([x().which for x in loader.scanner])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.scanner):
continue
else:
stream.initialize(loader.scanner[choice - 1])
elif choice == 5:
while True:
choice = util.print_menu([x().which for x in loader.parameter])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.parameter):
continue
else:
stream.initialize(loader.parameter[choice - 1])
elif choice == 6:
while True:
choice = util.print_menu([x().which for x in loader.services])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.services):
continue
else:
stream.initialize(loader.services[choice - 1])
elif choice == 7:
while True:
choice = util.print_menu([x().which for x in loader.attacks])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.attacks):
continue
else:
stream.initialize(loader.attacks[choice - 1])
elif choice == 8:
session_manager.menu()
elif choice == -1:
pass
# -*- coding: UTF-8 -*-
from flask import Flask, request, url_for, render_template, session, redirect
from urllib import quote_plus, unquote_plus
# app starts here
app = Flask(__name__)
app.config.from_object('settings.DevelopmentConfig')
# database module depends on app.config['DATABASE_URL']
from database import initialize
initialize(app.config['DATABASE_URL'])
# To use SQLAlchemy in a declarative way with your app, you just have to put the following code into your app module. Flask will automatically remove database sessions at the end of the request for you:
@app.teardown_request
def shutdown_session(exception=None):
from database import db_session
db_session.remove()
# register all blueprints
import index
import langs
from admin import admin, uploads, login, photos, users, settings, monitor
app.register_blueprint(index.bp, url_prefix='/')
app.register_blueprint(langs.bp, url_prefix='/lang')
app.register_blueprint(admin.bp, url_prefix='/admin')
app.register_blueprint(photos.bp, url_prefix='/admin/photos')
app.register_blueprint(users.bp, url_prefix='/admin/users')
app.register_blueprint(settings.bp, url_prefix='/admin/settings')
app.register_blueprint(uploads.bp, url_prefix='/admin/uploads')
def main():
""" Zarp entry point
"""
# set up configuration
config.initialize()
# set up database
database.initialize()
# load modules
loader = LoadedModules()
loader.load()
util.Msg('Loaded %d modules.' % loader.total)
# handle command line options first
if len(argv) > 1:
parse_cmd.parse(argv, loader)
# menus
main_menu = ['Poisoners', 'DoS Attacks', 'Sniffers', 'Scanners',
'Parameter', 'Services', 'Attacks', 'Sessions']
running = True
choice = -1
while running:
util.header()
choice = util.print_menu(main_menu)
if choice == 0:
# check if they've got running sessions!
cnt = stream.get_session_count()
if cnt > 0:
display = color.B_YELLOW + 'You have %d sessions running. ' + \
'Are you sure? ' + color.B_GREEN + '[' + color.B_YELLOW + \
'Y' + color.B_GREEN + '/' + color.B_YELLOW + 'n' + \
color.B_GREEN + '] ' + color.END
choice = raw_input(display % cnt)
if 'y' in choice.lower() or choice == '':
util.Msg('Shutting all sessions down...')
stream.stop_session('all', -1)
running = False
else:
util.debug("Exiting with session count: %d" % (cnt))
util.Msg("Exiting...")
running = False
# remove zarp temporary directory
util.init_app('rm -fr /tmp/.zarp/')
# recheck that all sessions are down
cnt = stream.get_session_count()
if cnt <= 0:
# some libs dont clean up their own threads, so
# we need to hard quit those to avoid hanging; FIXME
_exit(1)
elif choice == 1:
while True:
choice = util.print_menu([x().which for x in loader.poison])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.poison):
continue
else:
stream.initialize(loader.poison[choice - 1])
elif choice == 2:
while True:
choice = util.print_menu([x().which for x in loader.dos])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.dos):
continue
else:
stream.initialize(loader.dos[choice - 1])
elif choice == 3:
while True:
choice = util.print_menu([x().which for x in loader.sniffers])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.sniffers):
continue
else:
stream.initialize(loader.sniffers[choice - 1])
elif choice == 4:
while True:
choice = util.print_menu([x().which for x in loader.scanner])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.scanner):
continue
else:
stream.initialize(loader.scanner[choice - 1])
elif choice == 5:
while True:
choice = util.print_menu([x().which for x in loader.parameter])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.parameter):
continue
else:
stream.initialize(loader.parameter[choice - 1])
elif choice == 6:
while True:
choice = util.print_menu([x().which for x in loader.services])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.services):
continue
else:
stream.initialize(loader.services[choice - 1])
elif choice == 7:
while True:
choice = util.print_menu([x().which for x in loader.attacks])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.attacks):
continue
else:
stream.initialize(loader.attacks[choice - 1])
elif choice == 8:
session_manager.menu()
elif choice == -1:
pass
def get_distance(self):
for i in range(0, len(self.echoList)):
send_trig_pulse(self.trig)
wait_for_echo(self.echoList[i], True, 10000)
start = time.time()
wait_for_echo(self.echoList[i], False, 10000)
finish = time.time()
pulse_len = finish - start
distance_cm = pulse_len / 0.000058
self.dis[i] = distance_cm
return (self.dis)
cs_block = parkingLot(36, [40, 38], [31, 32], "SIT_CS_Block")
p = [0, 0]
firebase = database.initialize()
vehicle_CS = ["No", "No"]
prev_t = [0, 0]
vehicle_back = ['No', 'No']
while True:
disList = cs_block.get_distance()
print(disList)
time.sleep(2)
for i in range(0, len(disList)):
dis = disList[i]
if (dis > 4):
print("Parking slot" + str(i) + " is empty ", dis)
vehicle_CS[i] = database.retrieve_db(firebase, cs_block.lotName, i,
"vehicle")
if vehicle_CS[i] != "No":
vehicle_back[i] = vehicle_CS[i]
def update_cards(verbose=True):
session = Session()
bulk_data_uri = scryfall.get_bulk_data()
bulk_data = scryfall.bulk_data_generator(bulk_data_uri)
printings = (Printing.from_scryfall(p) for p in bulk_data)
session.add_all(printings)
with warnings.catch_warnings():
warnings.simplefilter('ignore', category=exc.SAWarning)
session.commit()
session.close()
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("action", help="Action you want to perform")
parser.add_argument("-n", "--name", type=str, help="")
parser.add_argument("-d", "--deck", type=str)
args = parser.parse_args()
if args.action == "initialize":
database.initialize(verbose=True)
elif args.action == "update":
update_sets()
update_cards()
elif args.action == "card":
if args.name:
result = Card.named(args.name)
print(result)
elif args.action == "add":
pass
# -*- coding: UTF-8 -*-
from flask import Flask, request, url_for, render_template, session, redirect
from urllib import quote_plus, unquote_plus
# app starts here
app = Flask(__name__)
app.config.from_object('settings.DevelopmentConfig')
# database module depends on app.config['DATABASE_URL']
from database import initialize
initialize(app.config['DATABASE_URL'])
# To use SQLAlchemy in a declarative way with your app, you just have to put the following code into your app module. Flask will automatically remove database sessions at the end of the request for you:
@app.teardown_request
def shutdown_session(exception=None):
from database import db_session
db_session.remove()
# register all blueprints
import index
import langs
from admin import admin, uploads, login, photos, users, settings, monitor
app.register_blueprint(index.bp, url_prefix='/')
app.register_blueprint(langs.bp, url_prefix='/lang')
app.register_blueprint(admin.bp, url_prefix='/admin')
app.register_blueprint(photos.bp, url_prefix='/admin/photos')
app.register_blueprint(users.bp, url_prefix='/admin/users')
app.register_blueprint(settings.bp, url_prefix='/admin/settings')
def setup():
from database import initialize
initialize()
pass
#print "Your turn:"
else:
pass
#print "Waiting for " + whosTurn
def generateDeck():
for suit in range(3,7):
for card in range(1,14):
deck.append((suit,card))
#= MainCode
start_new_thread(processSocket, ())
#read from database
database.initialize(traffic.getIP())
userList = database.getGlobalList()
#greet users in database
traffic.sendText(GREET, userList)
print "my IP is " + myIP
while True:
if gameStarted:
if players[turn] == myIP:
state = MY_TURN
else:
state = WAITING_FOR_TURN
if state == WAITING_FOR_GAME:
print "Waiting for players to join..."
#print "I think server is " + server
action = raw_input()
processAction(action)
def main():
""" Zarp entry point
"""
# set up configuration
config.initialize()
# set up database
database.initialize()
# load modules
loader = LoadedModules()
loader.load()
Msg('Loaded %d modules.' % loader.total)
# handle command line options first
if len(argv) > 1:
parse_cmd.parse(argv, loader)
# menus
main_menu = ['Poisoners', 'DoS Attacks', 'Sniffers', 'Scanners',
'Parameter', 'Services', 'Attacks', 'Sessions']
running = True
choice = -1
while running:
header()
choice = print_menu(main_menu)
if choice == 0:
# check if they've got running sessions!
cnt = stream.get_session_count()
if cnt > 0:
choice = raw_input(color.YELLOW +
'You have %d sessions running. Are you sure? [Y/n] ' % cnt
+ color.END)
if 'y' in choice.lower() or choice == '':
Msg('Shutting all sessions down...')
stream.stop_session('all', -1)
running = False
else:
debug("Exiting with session count: %d" % (cnt))
Msg("Exiting...")
running = False
elif choice == 1:
while True:
choice = print_menu([x().which for x in loader.poison])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.poison):
continue
else:
stream.initialize(loader.poison[choice - 1])
elif choice == 2:
while True:
choice = print_menu([x().which for x in loader.dos])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.dos):
continue
else:
stream.initialize(loader.dos[choice - 1])
elif choice == 3:
while True:
choice = print_menu([x().which for x in loader.sniffers])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.sniffers):
continue
else:
stream.initialize(loader.sniffers[choice - 1])
elif choice == 4:
while True:
choice = print_menu([x().which for x in loader.scanner])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.scanner):
continue
else:
stream.initialize(loader.scanner[choice - 1])
elif choice == 5:
while True:
choice = print_menu([x().which for x in loader.parameter])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.parameter):
continue
else:
stream.initialize(loader.parameter[choice - 1])
elif choice == 6:
while True:
choice = print_menu([x().which for x in loader.services])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.services):
continue
else:
stream.initialize(loader.services[choice - 1])
elif choice == 7:
while True:
choice = print_menu([x().which for x in loader.attacks])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.attacks):
continue
else:
stream.initialize(loader.attacks[choice - 1])
elif choice == 8:
session_manager.menu()
elif choice == -1:
pass
import database as db
import variables as vr
db.initialize('mytest')
# usage
ws_name1 = 'ws'
print('variable load..............')
variable = vr.get_variable('ws', 'newVar')
print(variable)
print('variable value data load..............')
print variable.value()
print('')
print('---------------------------------')
print('')
print('all variable load..............')
variables = vr.get_all_variables(workspace='ws')
print(variables)
for v in variables:
print v.value()
#repo.get_variable('ws', 'newVar')
#print( variabless)
def setupDB(self, db_path):
DB.initialize(db_path, self.dbCallback)
(r"/logout", login.login.Logout),
(r"/admin/overview", admin.overview.Handler),
(r"/admin/blacklist", admin.blacklist.Handler),
(r"/admin/bans", admin.bans.Handler),
(r"/admin/user_management", admin.user_management.Handler),
(r"/admin/server_list", admin.server_list.Handler),
],
cookie_secret=os.urandom(32),
xsrf_cookies=True,
static_path=os.path.join(os.path.dirname(__file__), "static"),
)
if __name__ == "__main__":
parse_command_line()
if not database.initialize():
exit(1)
if options.add_sysop is not None:
RANDOM_PW = util.generate_secret()
database.add_login(options.add_sysop, RANDOM_PW, True)
print("Password for {}: {}".format(options.add_sysop, RANDOM_PW))
exit(0)
if options.reset_pw is not None:
RANDOM_PW = util.generate_secret()
database.update_login(options.reset_pw, RANDOM_PW)
print("New password for {}: {}".format(options.reset_pw, RANDOM_PW))
exit(0)
APP = make_app()
def __init__(self):
database.initialize()
#!/usr/bin/env python3
import matplotlib.pyplot as plt
import numpy as np
import Orange
from pomegranate import *
import database
from database.models import Subject, Group, Incident, Weather
from database.processing import survival_rate, tabulate, export_as_orange
engine, session = database.initialize('sqlite:///../data/isrid-master.db')
query = session.query(Subject.survived, Group.size, Weather.avg_temp)
query = query.join(Group, Incident, Weather)
df = tabulate(query, [True, True, True])
database.terminate(engine, session)
print(sum(df.survived)/len(df))
log(f"Removing Client {clientId} from room {roomId}")
sockets[roomId].remove((ws, clientId))
db.removeUser(clientId, roomId)
# notify other users about the leaver
for peerWs in [x[0] for x in sockets[roomId]]:
if peerWs is not ws:
peerLeftNotice = {"peerLeft": {"id": clientId}}
await peerWs.send(json.dumps(peerLeftNotice))
if __name__ == '__main__':
log("Starting websocket server")
db.cursor = db.initialize()
if len(argv) > 1 and argv[1] == "--no-ssl":
start_server = websockets.serve(handler, '', 8001)
else:
certs = db.cursor.execute("SELECT * FROM ssl_certificates").fetchone()
certFile, keyFile = certs[0], certs[1]
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_context.load_cert_chain(certFile, keyFile)
start_server = websockets.serve(handler, '', 8001, ssl=ssl_context)
import ipdb
ipdb.set_trace()
expired_user_challenges = database.get_expired_challenges()
for user_challenge in expired_user_challenges:
user_id = user_challenge.get('userIdentifier')
user = database.get_user(user_id)
fitbit_api = fitbit.Fitbit('227QRF', 'aacdb90aaaa175c50e0556e1a50f35ab',
access_token=user.get('fitbit_access_token'))
activity_stats = fitbit_api.activity_stats(user_id=user.get('fitbit_id'))
steps = activity_stats['lifetime']['tracker']['steps']
challenge_id = user_challenge.get('challengeIdentifier')
uc = database.get_user_challenge(user_id, challenge_id)
challenge = database.get_challenge(challenge_id)
if (steps - uc.get('user_total_step_count_on_start')) >= challenge.get('steps_to_unlock'):
database.user_challenge_complete(user_id, challenge_id, challenge.get('reward_points'))
user = [{
'challengeId': 777,
'userId': 333
}]
return Response(json.dumps(user), status=httplib.CREATED, mimetype='application/json')
if __name__ == '__main__':
logger.debug('Initializing database ...')
database.initialize()
database.seed_challenges()
app.run(debug=True)
from timing_context import TimingContext
from utilities import json
from init_data import init_es_data, init_mongo_data
app = Flask(__name__, static_url_path="/static")
CORS(app, **config.get("apiserver.cors"))
Compress(app)
log = config.logger(__file__)
log.info("################ API Server initializing #####################")
app.config["SECRET_KEY"] = config.get("secure.http.session_secret.apiserver")
app.config["JSONIFY_PRETTYPRINT_REGULAR"] = config.get("apiserver.pretty_json")
database.initialize()
init_es_data()
init_mongo_data()
ServiceRepo.load("services")
log.info(f"Exposed Services: {' '.join(ServiceRepo.endpoint_names())}")
@app.before_first_request
def before_app_first_request():
pass
@app.before_request
def before_request():
def main():
""" Zarp entry point
"""
# set up configuration
config.initialize()
# set up database
database.initialize()
# load modules
loader = LoadedModules()
loader.load()
Msg("Loaded %d modules." % loader.total)
# handle command line options first
if len(argv) > 1:
parse_cmd.parse(argv, loader)
# menus
main_menu = ["Poisoners", "DoS Attacks", "Sniffers", "Scanners", "Parameter", "Services", "Attacks", "Sessions"]
running = True
choice = -1
while running:
header()
choice = print_menu(main_menu)
if choice == 0:
# check if they've got running sessions!
cnt = stream.get_session_count()
if cnt > 0:
choice = raw_input(
color.YELLOW + "You have %d sessions running. Are you sure? [Y/n] " % cnt + color.END
)
if "y" in choice.lower() or choice == "":
Msg("Shutting all sessions down...")
stream.stop_session("all", -1)
running = False
# recheck that all sessions are down
cnt = stream.get_session_count()
if cnt <= 0:
# some libs dont clean up their own threads, so
# we need to hard quit those to avoid hanging; FIXME
_exit(1)
else:
debug("Exiting with session count: %d" % (cnt))
Msg("Exiting...")
running = False
elif choice == 1:
while True:
choice = print_menu([x().which for x in loader.poison])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.poison):
continue
else:
stream.initialize(loader.poison[choice - 1])
elif choice == 2:
while True:
choice = print_menu([x().which for x in loader.dos])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.dos):
continue
else:
stream.initialize(loader.dos[choice - 1])
elif choice == 3:
while True:
choice = print_menu([x().which for x in loader.sniffers])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.sniffers):
continue
else:
stream.initialize(loader.sniffers[choice - 1])
elif choice == 4:
while True:
choice = print_menu([x().which for x in loader.scanner])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.scanner):
continue
else:
stream.initialize(loader.scanner[choice - 1])
elif choice == 5:
while True:
choice = print_menu([x().which for x in loader.parameter])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.parameter):
continue
else:
stream.initialize(loader.parameter[choice - 1])
elif choice == 6:
while True:
choice = print_menu([x().which for x in loader.services])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.services):
continue
else:
stream.initialize(loader.services[choice - 1])
elif choice == 7:
while True:
choice = print_menu([x().which for x in loader.attacks])
if choice == 0:
break
elif choice == -1:
pass
elif choice > len(loader.attacks):
continue
else:
stream.initialize(loader.attacks[choice - 1])
elif choice == 8:
session_manager.menu()
elif choice == -1:
pass
def setupDB(self, db_path):
DB.initialize(db_path, self.dbCallback)
def initialize(server_name):
global db
db = server_name + '.db'
conn = sqlite3.connect(db)
database.initialize(conn)
conn.close()