def test_find(self):
db = Connection('localhost', 27017).testdata
model.Group.delete_all(db)
g1 = model.Group("tos_kamiya FanClub", "Kamiya")
g2 = model.Group("ObaClub", "Oba")
g1.insert(db)
g2.insert(db)
act1 = model.Group.find(db, "Kamiya")
act2 = model.Group.find(db, "Oba")
self.assertTrue(act1 != None)
self.assertTrue(act2 != None)
def new_group():
group = model.Group(
name="New Group",
id=None,
parent_id=model.Group.query.filter_by(parent_id=None).first().id)
model.db.session.add(group)
model.db.session.commit()
return render_template('grouplight.html', e=group)
def create_group():
if request.method == "POST":
if "group_path" in request.form:
groupPath = request.form["group_path"]
try:
db.session.add(model.Group(groupPath,
request.form.get("description", "")))
db.session.commit()
except IntegrityError:
db.session.rollback()
return json.dumps({"result": False, "error": "Already exists"})
else:
pathLength = 3 # default
while True:
try:
groupPath = common.generate_random_string(int(pathLength))
db.session.add(model.Group(groupPath,
request.form.get("description", "")))
db.session.commit()
break
except IntegrityError:
db.session.rollback()
pathLength += 0.2
result = {}
for p in request.form.get("paths", "").split(","):
p = p.strip()
if not p:
continue
fileData = model.Path.query.filter(model.Path.Path == p).first()
if not fileData:
result.update({p: False})
fileData.Group = groupPath
db.session.commit()
result.update({p: True})
db.session.commit()
return json.dumps({"path": groupPath, "result": result})
return render_template("groups_create.html")
def init_database():
group = model.Group(id=1, name="All Lights", parent_id=None)
first_user = model.User(username="******", password="******")
settings = [model.Setting(name='city', value='Seattle')]
model.db.session.add(first_user)
for s in settings:
model.db.session.add(s)
model.db.session.add(group)
model.db.session.commit()
def post(self):
user = users.get_current_user()
usr = model.UserProfile.query(
model.UserProfile.userid == user.user_id()).get()
r = self.request.get('group_name')
group = model.Group()
group.name = r
group.members.append(usr)
group.knob = False
group.put()
self.redirect('/dashboard')
def parse_subscribe(source_id, text):
split_txt = text.split()
group_name = split_txt[2].lower()
g = model.Group.query().filter(model.Group.group_name == group_name).get()
if g is None:
g = model.Group(group_name=group_name)
if not source_id in g.subscribers:
g.subscribers.append(source_id)
g.put()
def post(self, **kwargs): # requires token
"""
@apiVersion 0.1.0
@apiUse TokenRequired
@api {post} /groups/ Create a new group
@apiName CreateGroup
@apiGroup Groups
@apiUse TokenRequired
@apiDescription Create a new group.
@apiParam {String} name A unique name for the group. You cant change this afterwards.
@apiParam {String} topic_area A topic area which describes the purpose of this group.
@apiParam {String} [password] The groups password.
@apiParam {String} description A description for group.
@apiUse UserAlreadyExistsError
@apiUse BadRequest
@apiUse SuccessfullyCreated
@apiUse ResourceAlreadyExistsError
@apiUse CouldNotBeSavedError
"""
parser = self.post_parser()
args = parser.parse_args()
user = kwargs.get('user')
user_info = user_model.User.query.get(user['user_id'])
user_uni = university_model.University.query.get(
user_info.university_id)
if user_info and user_uni:
new_group = model.Group(name=args['name'],
topic_area=args['topic_area'],
description=args['description'])
try:
if args['password']:
new_group.hash_password(args['password'])
new_group.owner = user_uni
db.session.add(new_group)
new_group.members.append(user_info)
db.session.commit()
return make_response(
jsonify({'message': 'added group to database'}), 201)
except IntegrityError as error:
db.session.rollback()
s = ""
if "Duplicate entry" in error.message:
s = "a group for this name already exists"
return make_response(jsonify({'message': s}), 409)
else:
s = "an error occured, the building could not be saved"
return make_response(jsonify({'message': s}), 500)
else:
return make_response(
jsonify({'message': 'no such group or university'}), 404)
def create_device_lights(mac):
# Create a group
new_group = model.Group(parent_id=1, name="Group")
model.db.session.add(new_group)
model.db.session.commit()
new_group.name = "Group {}".format(new_group.id)
model.db.session.commit()
# Create the lights
for i in xrange(4):
new_light = model.Light(parent_id=new_group.id,
name="Light",
device_mac=mac,
port=i)
model.db.session.add(new_light)
model.db.session.commit()
new_light.name = "Light {}".format(new_light.id)
model.db.session.commit()
####################
engine = create_engine(args.db_url)
Session = sessionmaker(bind=engine)
session = Session()
model.Base.metadata.create_all(engine)
model.session=session
# drop everything for reset
session.query(model.Guest).delete(synchronize_session='fetch')
session.query(model.Group).delete(synchronize_session='fetch')
# create a bunch of groups
for n in range(args.groups):
group=model.Group()
session.add(group)
session.commit()
# create a bunch of guests
for n in range(args.guests):
guest=model.Guest(tolerance=random.uniform(args.min_tolerance, args.max_tolerance))
session.add(guest)
session.commit()
for g in session.query(model.Guest).all():
g.update_happiness()
def debug(self):
group = session.query(model.Group).get('123')
if group is None:
group = model.Group(id='123')
session.add(group)
return group.id
import os, subprocess
import tensorflow as tf
import numpy as np
import globals, model, trainBot
from features import states_to_complex_states
if __name__ == '__main__':
if not os.path.exists("unit_test_outputs/"):
os.makedirs("unit_test_outputs/")
if 'session' in locals() and session is not None:
session.close()
with tf.Session() as sess:
team_group = model.Group()
sess.run(tf.global_variables_initializer())
print("Loading Model...")
t_vars = tf.trainable_variables()
vars_list = [var for var in t_vars]
saver = tf.train.Saver(var_list=vars_list)
saver.restore(sess, globals.MODEL_SAVE_PATH)
model.save_running_model_matrices(sess)
print("Done!")
trainer = trainBot.Trainer(team_group, 0, 0, sess)
with open("layer_output_test_input.txt", "r") as in_file:
server_content = in_file.read()
print(server_content)
si = trainBot.ServerInfo()
def test_insert(self):
db = Connection('localhost', 27017).testdata
model.Group.delete_all(db)
g1 = model.Group("tos_kamiya FanClub", "Kamiya")
g1.insert(db)
def test_init(self):
g1 = model.Group("tos_kamiya FanClub", "Kamiya")
def p_group_expression_comma_expression(p):
'group : expression SEP expression'
if p[3] is None:
raise ValueError("trailing group item is empty")
c = model.Group(p[1], p[3])
p[0] = c
def index():
# video1 = model.session.query(model.Track).get(55)
# video2 = model.session.query(model.Track).get(56)
video1 = model.session.query(model.Track).get(11)
video2 = model.session.query(model.Track).get(12)
groups = model.session.query(model.Group).all()
if request.method == 'POST':
# if (request.files['file1'] and request.files['file2']):
# print "in if statement"
# file1 = request.files['file1']
# file2 = request.files['file2']
file1 = None
file2 = None
new_title = request.form.get("title")
new_artist = request.form.get("artist")
new_event = request.form.get("event")
new_path = UPLOAD_FOLDER
# file upload
if (file1 and allowed_file(
file1.filename)) and (file2 and allowed_file(file2.filename)):
new_filename1 = secure_filename(file1.filename)
new_filename2 = secure_filename(file2.filename)
file1.save(os.path.join(app.config['UPLOAD_FOLDER'],
new_filename1))
file2.save(os.path.join(app.config['UPLOAD_FOLDER'],
new_filename2))
# youtube link upload
elif (request.form.get("url1") and request.form.get("url2")):
url1 = request.form.get("url1")
url2 = request.form.get("url2")
new_filename1 = convert.youtube_to_mp4(url1, new_title,
UPLOAD_FOLDER)
new_filename2 = convert.youtube_to_mp4(url2, new_title,
UPLOAD_FOLDER)
new_youtube_url1 = "http://www.youtube.com/embed/" + url1[-11:]
new_youtube_url2 = "http://www.youtube.com/embed/" + url2[-11:]
new_thumbnail1 = convert.youtube_thumbnail(url1)
new_thumbnail2 = convert.youtube_thumbnail(url2)
# save file 1
# new_filename_webm1 = convert.convert_video(filename1, UPLOAD_FOLDER) # convert file to webm
new_filename_webm1 = "webmfilename"
new_file1 = model.Track(title=new_title,
filename=new_filename1,
artist=new_artist,
event=new_event,
path=new_path,
filename_webm=new_filename_webm1,
youtube_url=new_youtube_url1,
thumbnail_url=new_thumbnail1)
model.session.add(new_file1)
# save file 2
# new_filename_webm2 = convert.convert_video(filename2, UPLOAD_FOLDER) # convert file to webm
new_filename_webm2 = "webmfilename"
new_file2 = model.Track(title=new_title,
filename=new_filename2,
artist=new_artist,
event=new_event,
path=new_path,
filename_webm=new_filename_webm2,
youtube_url=new_youtube_url2,
thumbnail_url=new_thumbnail2)
model.session.add(new_file2)
# save group info into db
new_timestamp = datetime.datetime.now()
new_group = model.Group(timestamp=new_timestamp)
model.session.add(new_group)
model.session.flush()
# analyze delay
delay = alignment_by_row_channels.align(new_filename1, new_filename2,
UPLOAD_FOLDER)
# delay = (0, 5)
# save analysis into db
new_group_id = new_group.id
new_track_id1 = new_file1.id
new_sync_point1 = delay[0]
new_analysis1 = model.Analysis(group_id=new_group_id,
track_id=new_track_id1,
sync_point=new_sync_point1)
model.session.add(new_analysis1)
new_track_id2 = new_file2.id
new_sync_point2 = delay[1]
new_analysis2 = model.Analysis(group_id=new_group_id,
track_id=new_track_id2,
sync_point=new_sync_point2)
model.session.add(new_analysis2)
model.session.commit()
return redirect('/watch?group_id=' + str(new_group.id))
return render_template("index.html",
video1=video1,
video2=video2,
groups=groups)
