def _create_app_manager():
my_manager = ServerManager()
if isfile(ServerManager.PICKLE_FILENAME):
logger.info("Load server data from file")
my_manager.load_state(init=True)
else:
logger.info("Create new server data")
asset_list = [
PestBox("AutumnFly"),
PestBox("Greenfly"),
PestBox("Dogmite"),
CFS("itchy", MetaswitchAsset.SOLARIS)]
my_manager.add_assets(asset_list)
return my_manager
async def on_reaction_add(
self,
reaction: discord.Reaction,
user: discord.User,
) -> None:
if user == self.user:
# Don't let the bot listen to reactions from itself
return
mgr = ServerManager.try_load(self.lock, self.mgr_path)
await mgr.handle_reaction_add(self, reaction, user, self.db_conn)
def __init__(self):
gtk.Window.__init__(self)
pynotify.init('PyCruiseTray')
# Create ServerManager
self.server_manager = ServerManager()
# Load servers
self.load_servers()
# Load BuildIcons
self.build_icons = BuildIcons()
self.statusicon = gtk.StatusIcon()
self.statusicon.set_from_stock(gtk.STOCK_APPLY)
self.statusicon.connect("popup-menu", self.right_click_event)
self.statusicon.connect("activate", self.status_clicked)
self.statusicon.set_tooltip("PyCruiseTray")
self.connect("delete-event", self.delete_event)
self.connect("destroy", lambda w: gtk.main_quit())
# Create TreeStore for Server list
self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self.treeview = gtk.TreeView(self.liststore)
# Create TreeViewColumns to display data
cell = gtk.CellRendererPixbuf()
col = gtk.TreeViewColumn("Status", cell, pixbuf=0)
self.treeview.append_column(col)
cell = gtk.CellRendererText()
col = gtk.TreeViewColumn("Name", cell, text=1)
self.treeview.append_column(col)
cell = gtk.CellRendererText()
col = gtk.TreeViewColumn("URL", cell, text=2)
self.treeview.append_column(col)
self.add(self.treeview)
self.set_size_request(450, 300)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title("PyCruiseTray")
self.menu = ContextMenu(self, self.build_icons)
self.show_all()
# Start update thread (run every 5 minutes)
self.update_projects()
self.thread = gobject.timeout_add(60000, self.update_projects)
async def on_message(self, message: discord.Message) -> None:
if message.author == self.user:
# Don't let the bot respond to itself
return
# Test messages are designated with a leading "tt "
if self.is_test:
if message.content.startswith("tt "):
message.content = message.content[len("tt "):]
else:
return
mgr = ServerManager.try_load(self.lock, self.mgr_path)
await mgr.handle_message(self, message, self.db_conn)
def setup_app(app: Flask, args: object):
setup_logger()
# if enabled allow the GPU to run the server, else use the CPU
torch_device = 'cuda' if args.cuda and torch.cuda.is_available() else 'cpu'
print(f'Using device: {torch_device}...')
logging.info(f'Using device: {torch_device}...')
SERVER_STATE["server_manager"] = ServerManager(thread_manager,
torch_device)
if args.load_state:
with open("server_state.pkl", 'rb') as f:
state = pickle.load(f)
SERVER_STATE["server_manager"].load_state(state, "server_manager")
@app.route('/api/set_session/', methods=['GET'])
def create_experiment():
session_id, ner_class, user_name = get_keys_from_data(
request.args, 'session_id', 'ner_class', 'user_name')
server_manager = SERVER_STATE["server_manager"]
user_state = server_manager.get_user_state(user_name)
building = user_state.set_session_state(session_id=session_id,
ner_class=ner_class)
if not building:
logging.info("Preserving state, no need to reload")
return jsonify({"messsage": "success"}), 201
@app.route('/api/get_query/', methods=['GET'])
def get_query():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
user_state = server_manager.get_user_state(user_name)
al_manager = user_state.get_al_manager()
if al_manager.get_is_start():
user_state.set_start_time()
query, query_predictions, final_batch = al_manager.get_query()
if query is None and user_state.get_end_time() is None:
user_state.set_end_time()
return jsonify({
"results": query,
"predictions": query_predictions,
"final_batch": final_batch,
}), 201
@app.route('/api/add_examples/', methods=['POST'])
def add_examples():
'''
assuming arguments come as a list of (sentence_id, sentence, label)
in an arugment called examples
'''
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
al_manager = server_manager.get_user_state(user_name).get_al_manager()
json_data = json.loads(request.data)
examples = get_keys_from_data(json_data, 'data')[0]
sentence_ids = []
labels = []
try:
for s_id, (s, ranges) in examples.items():
sentence_ids.append(int(s_id))
labels.append(
al_manager.convert_word_ranges_to_labels(s, ranges))
al_manager.update_examples(sentence_ids, labels)
return jsonify({"messsage": "success"}), 201
except:
with open('log.txt', 'w') as f:
f.writelines(str(json_data))
f.writelines(str(examples.items()))
@app.route('/api/train/', methods=['GET'])
def get_experiment():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
al_manager = server_manager.get_user_state(user_name).get_al_manager()
thread_id = al_manager.train()
return jsonify({
'thread_id': thread_id,
}), 200
@app.route('/api/evaluate/', methods=['GET'])
def get_all_experiments():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
al_manager = server_manager.get_user_state(user_name).get_al_manager()
eval_results = al_manager.evaluate()
return jsonify(eval_results), 200
@app.route('/api/sessions/', methods=['GET'])
def get_all_sessions():
db_manager = SERVER_STATE["database_manager"]
return jsonify(db_manager.get_all_session_info()), 200
@app.route('/api/predictions/', methods=['GET'])
def get_predictions():
# retrieves precomputed predictions
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
al_manager = server_manager.get_user_state(user_name).get_al_manager()
if al_manager is None:
return jsonify({"error": "unknown user"}), 200
return jsonify(al_manager.get_predictions()), 200
@app.route('/api/progress/', methods=['GET'])
def get_progress():
thread_id = int(get_keys_from_data(request.args, 'thread_id')[0])
thread_manager = SERVER_STATE["thread_manager"]
prog = thread_manager.get_progress(thread_id)
return jsonify(prog), 200
@app.route('/api/trainer_progress/', methods=['GET'])
def get_trainer_progress():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
al_manager = server_manager.get_user_state(user_name).get_al_manager()
res = al_manager.get_training_progress()
return jsonify(res, ), 200
@app.route('/api/compute_ground_truth/', methods=['GET'])
def get_ground_truth_result():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
al_manager = server_manager.get_user_state(user_name).get_al_manager()
res = al_manager.evaluate_ground_truth()
return jsonify(res, ), 200
@app.route('/api/users/', methods=['GET'])
def get_all_users():
server_manager = SERVER_STATE["server_manager"]
return jsonify(server_manager.get_all_users()), 200
@app.route('/api/add_users/', methods=['POST'])
def add_user():
server_manager = SERVER_STATE["server_manager"]
json_data = json.loads(request.data)
user_name = get_key_from_data(json_data, 'user_name')
res = server_manager.add_user(user_name)
return jsonify(res), 201
@app.route('/api/save_server_state/', methods=['GET'])
def save_server_state():
state = {}
server_manager = SERVER_STATE["server_manager"]
server_manager.save_state(state, "server_manager")
with open("server_state.pkl", "wb") as f:
pickle.dump(state, f)
return jsonify("Success"), 201
@app.route('/api/save_model/', methods=['GET'])
def save_user_model():
server_manager = SERVER_STATE["server_manager"]
user_name = get_key_from_data(request.args, 'user_name')
al_manager = server_manager.get_user_state(user_name).save_model()
return jsonify("Success"), 201
@app.route('/api/load_model/', methods=['GET'])
def load_user_model():
server_manager = SERVER_STATE["server_manager"]
user_name = get_key_from_data(request.args, 'user_name')
al_manager = server_manager.get_user_state(user_name).load_model()
return jsonify("Success"), 201
@app.route('/api/submit_turk_survey/', methods=['POST'])
def submit_turk_survey():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
firebase_manager = SERVER_STATE["firebase_manager"]
server_manager = SERVER_STATE["server_manager"]
user_state = server_manager.get_user_state(user_name)
al_manager = server_manager.get_user_state(user_name).get_al_manager()
preds = al_manager.get_predictions()
json_data = json.loads(request.data)
survey_info = json_data['submit_data']
survey_info['user_name'] = user_name
survey_info['start_time'] = user_state.get_start_time()
survey_info['end_time'] = user_state.get_end_time()
survey_info['labeled_example_sizes'] = preds['labeled_set_sizes']
survey_info['training_summary'] = preds['training_summary']
survey_info['flipped_data'] = preds['flipped_data']
survey_info['experiment_stats'] = al_manager.experiment_stats
survey_code = survey_utils.submit_survey(firebase_manager, survey_info)
try:
server_manager.get_user_state(user_name).save_model()
server_manager.get_user_state(user_name).save_data()
except Exception as e:
print('Error ocurred while attempting to save state')
logging.exception(e)
return jsonify({"survey_code": survey_code}), 201
@app.route('/api/has_completed_task/', methods=['GET'])
def check_if_user_completed_task():
server_manager = SERVER_STATE["server_manager"]
user_name = get_key_from_data(request.args, 'user_name')
firebase_manager = SERVER_STATE["firebase_manager"]
exists = firebase_manager.user_exists(user_name)
return jsonify({"exists": exists}), 200
@app.route('/api/used_cheatsheet/', methods=['GET'])
def used_cheatsheet():
user_name = get_key_from_data(request.args, 'user_name')
server_manager = SERVER_STATE["server_manager"]
user_state = server_manager.get_user_state(user_name)
al_manager = user_state.get_al_manager()
al_manager.experiment_stats["used_cheatsheet"].append(time.time())
return jsonify({"success": True}), 200
from sqlalchemy.orm.exc import NoResultFound
from setup_database import Base, Player, Server, Match, Player_Match, User
from flask import session as login_session
import string
import os
import random
import json
import socket
from flask import make_response, send_from_directory
import requests
from server_manager import ServerManager
from oauth2client.client import flow_from_clientsecrets
from oauth2client.client import FlowExchangeError
import httplib2
manager = ServerManager()
app = Flask(__name__)
engine = create_engine('sqlite:///ranks.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
CLIENT_ID = json.loads(open('client_secrets.json',
'r').read())['web']['client_id']
@app.context_processor
def utility_processor():
user = None
if 'email' in login_session:
user = session.query(User).\
import time, sys
from app import app
sys.path.append('/home/pi/Documents/3CB101-Pi/project/web_server/server')
sys.path.append("server")
from server_manager import ServerManager
from flask import Flask, Response, request, render_template, redirect
global server_manager_instance
server_manager_instance = ServerManager()
server_manager_instance.setup()
server_manager_instance.start()
socket_ip = server_manager_instance.get_socket_ip()
@app.route('/socket_call')
def socket_call():
socket_instance = server_manager_instance.get_socket_instance()
socket_code = request.args.get('socket_code', None)
if socket_code == "get_data":
print('api call: ', get_data())
elif socket_code != None:
socket_instance.server_request(socket_code)
return redirect("/public/debug")
@app.route('/start')
def start():
socket_instance = server_manager_instance.get_socket_instance()
socket_instance.server_request('session_start')
return redirect("/public/debug")
class PyCruiseTray(gtk.Window):
def __init__(self):
gtk.Window.__init__(self)
pynotify.init('PyCruiseTray')
# Create ServerManager
self.server_manager = ServerManager()
# Load servers
self.load_servers()
# Load BuildIcons
self.build_icons = BuildIcons()
self.statusicon = gtk.StatusIcon()
self.statusicon.set_from_stock(gtk.STOCK_APPLY)
self.statusicon.connect("popup-menu", self.right_click_event)
self.statusicon.connect("activate", self.status_clicked)
self.statusicon.set_tooltip("PyCruiseTray")
self.connect("delete-event", self.delete_event)
self.connect("destroy", lambda w: gtk.main_quit())
# Create TreeStore for Server list
self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self.treeview = gtk.TreeView(self.liststore)
# Create TreeViewColumns to display data
cell = gtk.CellRendererPixbuf()
col = gtk.TreeViewColumn("Status", cell, pixbuf=0)
self.treeview.append_column(col)
cell = gtk.CellRendererText()
col = gtk.TreeViewColumn("Name", cell, text=1)
self.treeview.append_column(col)
cell = gtk.CellRendererText()
col = gtk.TreeViewColumn("URL", cell, text=2)
self.treeview.append_column(col)
self.add(self.treeview)
self.set_size_request(450, 300)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title("PyCruiseTray")
self.menu = ContextMenu(self, self.build_icons)
self.show_all()
# Start update thread (run every 5 minutes)
self.update_projects()
self.thread = gobject.timeout_add(60000, self.update_projects)
def load_servers(self):
self.servers = []
for server in self.server_manager.list():
self.servers.append(CruiseControlServer(server['name'], server['url']))
def update_projects(self):
projects = []
for server in self.servers:
server.load_projects()
projects.extend(server.projects)
self.show_projects_list(projects)
self.menu.update(projects)
failures = filter((lambda p: 'Failure' in p.get_build_status()), projects)
# Change StatusIcon accordingly
if len(failures) > 0:
self.statusicon.set_from_pixbuf(self.build_icons.get_icon('Failure.Sleeping'))
else:
self.statusicon.set_from_pixbuf(self.build_icons.get_icon('Success.Sleeping'))
for fail in failures:
notification = pynotify.Notification("Build failure", "Project %s failed to build!" % fail.name)
notification.attach_to_status_icon(self.statusicon)
notification.set_urgency(pynotify.URGENCY_CRITICAL)
notification.set_timeout(10000)
notification.show()
return True
def show_projects_list(self, projects):
self.liststore.clear()
for project in projects:
icon = self.build_icons.get_icon(project.get_build_status())
self.liststore.append([icon, project.name, project.url])
def status_clicked(self, status):
self.show_all()
def delete_event(self, window, event):
self.hide_on_delete()
return True
def right_click_event(self, icon, button, time):
self.menu.popup(None, None, gtk.status_icon_position_menu, button, time, self.statusicon)
