def standalone():
db = Session()
while True:
try:
log.info("Opening serial port")
ser = serial.Serial('/dev/ttyACM0', 115200, timeout=10)
log.info("Serial port open")
while True:
line = ser.readline()
if line:
(node_id, seq_no, reading_type, reading,
checksum_sent, checksum_calc) = line.split(" ")
r = Reading()
r.node_id = int(node_id)
r.seq_no = int(seq_no)
r.reading_type = reading_type
r.reading = float(reading)
r.checksum_sent = int(checksum_sent, 16)
r.checksum_calc = int(checksum_calc, 16)
db.add(r)
db.commit();
log.info("Read line: %r", line)
except Exception:
log.exception("Exception")
time.sleep(20)
def test_add_and_get_data(get_example_data):
with Session.begin() as s:
CrudTable().add_data(s, get_example_data)
with Session.begin() as s:
assert len(CrudTable().get_data(s)) == 6
assert len(CrudTable().get_data(s, user_name="Tom Cat")) == 1
assert len(CrudTable().get_data(s, user_name="Jerry Mouse")) == 1
def game_count(self):
s = Session()
gameCount = s.query(Champion).\
join(Match, Champion.match_id == Match.match_id).\
filter(Champion.champion_key == self.championKey).\
filter(Match.created_on > (
datetime.utcnow() - timedelta(days=self.days))).count()
return gameCount
def game_count(self):
s = Session()
gameCount = s.query(Champion).\
join(Match, Champion.match_id == Match.match_id).\
filter(Champion.champion_key == self.championKey).\
filter(Match.created_on > (
datetime.utcnow() - timedelta(days=self.days))).count()
return gameCount
def evaluate(model, dictionary, session_queries):
session = Session()
session.queries = session_queries
session_queries, session_query_length, rel_docs, rel_docs_length, doc_labels = helper.session_to_tensor(
[session], dictionary, iseval=True)
if model.config.cuda:
session_queries = session_queries.cuda()
session_query_length = session_query_length.cuda()
return suggest_next_query(model, session_queries, session_query_length, dictionary)
def evaluate(model, dictionary, session_queries):
sess = Session()
sess.queries = session_queries
session_tensor, query_lengths = helper.session_to_tensor([sess],
dictionary, True)
if args.cuda:
session_tensor = session_tensor.cuda()
query_lengths = query_lengths.cuda()
return suggest_next_query(model, dictionary, session_tensor, query_lengths)
def test_update_data():
new_data = {"email": "*****@*****.**"}
with Session.begin() as s:
target = CrudTable().get_data(s, email="*****@*****.**")
assert len(target) == 0
user = CrudTable().get_data(s, email="*****@*****.**")[0]
CrudTable().update_data(user, new_data)
with Session.begin() as s:
target = CrudTable().get_data(s, email="*****@*****.**")
assert len(target) == 1
def main():
name = sys.argv[1]
session = Session()
team_a = session.query(Team).filter(Team.name == "Matematici").one()
team_b = session.query(Team).filter(Team.name == "Fisici").one()
sched_begin = datetime.datetime.strptime(sys.argv[2], '%Y-%m-%d %H:%M:%S')
sched_end = datetime.datetime.strptime(sys.argv[3], '%Y-%m-%d %H:%M:%S')
match_id = act_init_match(session, name, team_a, team_b, sched_begin, sched_end)
session.commit()
print "> Created match with ID %d" % (match_id)
def done(self, _):
"""Saves the current performer details"""
session = Session() # Get a database session
performer = self._target(session)
performer.name = self.name.get_edit_text()
performer.email = self.email.get_edit_text()
performer.mobile = self.mobile.get_edit_text()
performer.nfc = self.nfc.get_edit_text()
session.add(performer)
session.commit()
self.callback(None, performer)
def insert_tags(all_tags):
s = Session()
for tag in all_tags:
t = Tags(name=tag)
try:
s.add(t)
s.commit()
print "Added:", tag
except IntegrityError as e:
s.rollback()
pass
def create_teams():
session = Session()
Base.metadata.create_all()
session.commit()
t1 = Team()
t1.name = 'Matematici'
t2 = Team()
t2.name = 'Fisici'
session.add(t1)
session.add(t2)
session.commit()
def __init__(self, match_id):
self.session = Session()
self.match = self.session.query(Match).filter(Match.id == match_id).one()
self.teams = [self.match.team_a, self.match.team_b]
self.order = [None, None]
self.queues = [[], []]
self.score = [0, 0]
self.players = [[None, None], [None, None]]
self.listeners = []
self.last_event_id = 0
self.last_player_match_id = 0
self.last_timestamp = None
def get(self):
sess = Session()
self.set_header("Content-Type", "application/json")
self.write('{"num_nodes":3,"readings":[')
i = 0
last_timestamp = {}
now = datetime.datetime.utcnow()
one_month_ago = now - datetime.timedelta(days=30)
one_year_ago = now - datetime.timedelta(days=365)
one_week_ago = now - datetime.timedelta(days=7)
one_day_ago = now - datetime.timedelta(days=1)
for r in (sess.query(Reading).
filter(Reading.checksum_calc == Reading.checksum_sent).
filter(Reading.created_at > one_year_ago).
order_by(Reading.created_at)):
if r.created_at < one_month_ago:
min_delta = datetime.timedelta(hours=4)
elif r.created_at < one_week_ago:
min_delta = datetime.timedelta(hours=2)
elif r.created_at < one_day_ago:
min_delta = datetime.timedelta(hours=1)
else:
min_delta = datetime.timedelta()
if (last_timestamp.get(r.node_id, None) is None or
r.created_at > last_timestamp[r.node_id] + min_delta):
self.write(("" if i == 0 else ",") +
cjson.encode([time.mktime(r.created_at.timetuple()), #@UndefinedVariable
r.reading if r.node_id == 1 else None,
r.reading if r.node_id == 2 else None,
r.reading if r.node_id == 3 else None]))
last_timestamp[r.node_id] = r.created_at
i += 1
if (i % 20) == 0:
self.flush()
self.finish("]}")
def main(filename):
Base.metadata.create_all(Engine)
session = Session()
fortunes = pd.read_csv(filename)
for index, row in fortunes.iterrows():
logger.info('Loading rank {} into DB'.format(row['rank']))
fortune = Fortune(row['rank'],
row['title'],
row['website'],
row['employees'],
row['sector'],
row['industry'])
session.add(fortune)
session.commit()
session.close()
def attach_foreignkeys(gen):
s = Session()
all_answers = {x[0] for x in s.query(Answers.id).all()}
print "Answers loaded."
for index, line in enumerate(gen):
line = line.strip()
if line.startswith("<row"):
node = etree.fromstring(line)
post_object = node.attrib
if post_object.get('PostTypeId') == "1":
attach_question(s, post_object, all_answers)
if post_object.get('PostTypeId') == "2":
attach_answer(s, post_object)
if index % 2000 == 0:
print index, "attached."
sys.stdout.flush()
if index % 50000 == 0:
s.commit()
s.commit()
def parse_lines(gen):
s = Session()
for index, line in enumerate(gen):
line = line.strip()
if line.startswith("<row"):
node = etree.fromstring(line)
post_object = node.attrib
if post_object.get('PostTypeId') == "1":
process_questions(s, post_object)
if post_object.get('PostTypeId') == "2":
process_answers(s, post_object)
if index % 2000 == 0:
print index, "processed."
sys.stdout.flush()
if index % 50000 == 0:
s.commit()
s.commit()
def standalone():
db = Session()
while True:
try:
log.info("Opening serial port")
serial = pyserial.Serial('COM3', 115200, timeout=10) #/dev/ttyACM0
log.info("Serial port open")
while True:
line = str(serial.readline(), 'ascii')
if line:
(node_id, seq_no, reading_type, temperature,
checksum_sent, checksum_calc) = line.split(" ")
reading = Reading()
reading.node_id = int(node_id)
reading.seq_no = int(seq_no)
reading.reading_type = reading_type
reading.reading = float(temperature)
reading.checksum_sent = int(checksum_sent, 16)
reading.checksum_calc = int(checksum_calc, 16)
db.add(reading)
db.commit()
log.info("Read line: %r", line)
setpoint = db.query(Setpoint).filter(Setpoint.zone_id == reading.node_id).order_by(desc(Setpoint.created_at)).first()
if setpoint is not None:
log.info("actual temp %s desired temp %s" % (reading.reading, setpoint.temperature))
if setpoint.temperature > reading.reading:
serial.write(struct.pack('!B', (reading.node_id << 1))) # flip that zone to on
log.info("opening zone %s" % reading.node_id)
else:
serial.write(struct.pack('!B', (reading.node_id << 1) + 1)) # flip that zone to off
log.info("closing zone %s" % reading.node_id)
except Exception:
log.exception("Exception")
time.sleep(20)
turns=self.turns)
def usage():
"""Print usage and exit."""
print "Usage: {} match_id filename".format(sys.argv[0])
sys.exit(1)
if __name__ == "__main__":
try:
match_id = int(sys.argv[1])
filename = sys.argv[2]
except IndexError, ValueError:
usage()
session = Session()
players = {}
try:
# Load turns from csv file
turns = []
with open(filename, "rb") as csvfile:
csvreader = csv.reader(csvfile, delimiter=",", quotechar="'")
for row in csvreader:
turn = Turn.from_csv_line(row)
turns.append(turn)
for team in (1, 2):
for player_id in turn.players[team]:
if player_id not in players:
players[player_id] = PlayerInfo(player_id, team)
# print(turns)
class SubottoCore:
def __init__(self, match_id):
self.session = Session()
self.match = self.session.query(Match).filter(Match.id == match_id).one()
self.teams = [self.match.team_a, self.match.team_b]
self.order = [None, None]
self.queues = [[], []]
self.score = [0, 0]
self.players = [[None, None], [None, None]]
self.listeners = []
self.last_event_id = 0
self.last_player_match_id = 0
self.last_timestamp = None
def close(self):
self.session.rollback()
self.session.close()
def detect_team(self, team):
if team == self.match.team_a:
return 0
else:
return 1
def new_player_match(self, player_match):
print >> sys.stderr, "> Received new player match: %r" % (player_match)
for listener in self.listeners:
listener.new_player_match(player_match)
def new_event(self, event):
print >> sys.stderr, "> Received new event: %r" % (event)
if event.type == Event.EV_TYPE_SWAP:
self.order = [event.red_team, event.blue_team]
elif event.type == Event.EV_TYPE_CHANGE:
self.players[self.detect_team(event.team)] = [event.player_a, event.player_b]
elif event.type == Event.EV_TYPE_GOAL:
self.score[self.detect_team(event.team)] += 1
elif event.type == Event.EV_TYPE_GOAL_UNDO:
self.score[self.detect_team(event.team)] -= 1
elif event.type == Event.EV_TYPE_ADVANTAGE_PHASE:
pass
else:
print >> sys.stderr, "> Wrong event type %r\n" % (event.type)
for listener in self.listeners:
listener.new_event(event)
def regenerate(self):
print >> sys.stderr, "> Regeneration"
for listener in self.listeners:
listener.regenerate()
def update(self):
self.session.rollback()
for player_match in self.session.query(PlayerMatch).filter(PlayerMatch.match == self.match).filter(PlayerMatch.id > self.last_player_match_id).order_by(PlayerMatch.id):
self.new_player_match(player_match)
self.last_player_match_id = player_match.id
for event in self.session.query(Event).filter(Event.match == self.match).filter(Event.id > self.last_event_id).order_by(Event.id):
if self.last_timestamp is not None and event.timestamp <= self.last_timestamp:
print >> sys.stderr, "> Timestamp monotonicity error at %s!\n" % (event.timestamp)
#sys.exit(1)
self.new_event(event)
self.last_timestamp = event.timestamp
self.last_event_id = event.id
for idx in [0, 1]:
team = self.teams[idx]
this_num = 0
self.queues[idx] = []
for queue_element in self.match.get_queue(team):
if queue_element.num != this_num:
printf >> sys.stderr, "> Error: queues are inconsistent"
this_num += 1
self.queues[idx].append((queue_element.player_a, queue_element.player_b))
self.regenerate()
return True
def act_event(self, event, source=None):
event.timestamp = now()
event.match = self.match
if source is None:
event.source = Event.EV_SOURCE_MANUAL
else:
event.source = source
if not event.check_type():
print >> sys.stderr, "> Sending bad event..."
self.session.add(event)
self.session.commit()
self.update()
def act_switch_teams(self, source=None):
e = Event()
e.type = Event.EV_TYPE_SWAP
if self.order == [None, None]:
e.red_team = self.teams[0]
e.blue_team = self.teams[1]
else:
e.red_team = self.order[1]
e.blue_team = self.order[0]
self.act_event(e, source)
def act_goal(self, team, source=None):
e = Event()
e.type = Event.EV_TYPE_GOAL
e.team = team
self.act_event(e, source)
def act_goal_undo(self, team, source=None):
e = Event()
e.type = Event.EV_TYPE_GOAL_UNDO
e.team = team
self.act_event(e, source)
def act_team_change(self, team, player_a, player_b, source=None):
e = Event()
e.type = Event.EV_TYPE_CHANGE
e.team = team
e.player_a = player_a
e.player_b = player_b
self.act_event(e, source)
def act_add_to_queue(self, team, player_a, player_b):
qe = QueueElement()
qe.match = self.match
qe.team = team
qe.player_a = player_a
qe.player_b = player_b
qe.num = len(self.queues[self.detect_team(team)])
self.session.add(qe)
self.session.commit()
self.update()
def act_remove_from_queue(self, team, num):
queue = self.match.get_queue(team)
self.session.delete(queue[num])
self.session.flush()
del queue[num]
# Indirect assignement to prevent failing constraints
for i in xrange(num, len(queue)):
queue[i].num = None
self.session.flush()
for i in xrange(num, len(queue)):
queue[i].num = i
self.session.commit()
self.update()
def act_swap_queue(self, team, num1, num2):
queue = self.match.get_queue(team)
# Indirect assignement to prevent failing constraints
queue[num1].num = None
queue[num2].num = None
self.session.flush()
queue[num1].num = num2
queue[num2].num = num1
self.session.commit()
self.update()
def act_begin_match(self, begin=None):
if begin is None:
begin = datetime.datetime.now()
self.match.begin = begin
self.session.commit()
def act_end_match(self, end=None):
if end is None:
end = datetime.datetime.now()
self.match.end = end
self.session.commit()
def act_add_player_match_from_name(self, team, fname, lname, comment=None, bulk=False):
player = Player.get_or_create(self.session, fname, lname, comment)
try:
player_match = self.session.query(PlayerMatch).filter(PlayerMatch.match == self.match). \
filter(PlayerMatch.player == player).one()
except NoResultFound:
player_match = PlayerMatch()
player_match.player = player
player_match.match = self.match
player_match.team = team
self.session.add(player_match)
if not bulk:
self.session.commit()
def easy_get_red_team(self):
return self.order[0]
def easy_get_blue_team(self):
return self.order[1]
def easy_get_red_score(self):
return self.score[self.detect_team(self.easy_get_red_team())]
def easy_get_blue_score(self):
return self.score[self.detect_team(self.easy_get_blue_team())]
def easy_act_red_goal_cell(self):
self.act_goal(self.easy_get_blue_team(), source=Event.EV_SOURCE_CELL_RED_PLAIN)
def easy_act_red_supergoal_cell(self):
self.act_goal(self.easy_get_blue_team(), source=Event.EV_SOURCE_CELL_RED_SUPER)
def easy_act_red_goal_button(self):
self.act_goal(self.easy_get_red_team(), source=Event.EV_SOURCE_BUTTON_RED_GOAL)
def easy_act_red_goalundo_button(self):
self.act_goal_undo(self.easy_get_red_team(), source=Event.EV_SOURCE_BUTTON_RED_UNDO)
def easy_act_blue_goal_cell(self):
self.act_goal(self.easy_get_red_team(), source=Event.EV_SOURCE_CELL_BLUE_PLAIN)
def easy_act_blue_supergoal_cell(self):
self.act_goal(self.easy_get_red_team(), source=Event.EV_SOURCE_CELL_BLUE_SUPER)
def easy_act_blue_goal_button(self):
self.act_goal(self.easy_get_blue_team(), source=Event.EV_SOURCE_BUTTON_BLUE_GOAL)
def easy_act_blue_goalundo_button(self):
self.act_goal_undo(self.easy_get_blue_team(), source=Event.EV_SOURCE_BUTTON_BLUE_UNDO)
def run(self):
session = Session()
last_id = Log.get_last_id(session, simulate_time=self.simulate_time)
if last_id is None:
last_id = 0
last_id -= BUFFER_LEN
time_delta = None
if self.simulate_time:
time_delta = monotonic_time() - self.simulate_time
while not self.closing:
query = session.query(Log).filter(Log.id > last_id).filter(Log.interesting == True).order_by(Log.id)
if time_delta is not None:
log2 = session.query(Log).filter(Log.interesting == True).filter(Log.timestamp <= monotonic_time() - time_delta).order_by(Log.timestamp.desc()).first()
query = query.filter(Log.id <= log2.id)
new_data = query.all()
if len(new_data) > 0:
last_id = new_data[-1].id
#print >> sys.stderr, "Read %d records" % (len(new_data))
self.buffer += new_data
self.buffer = self.buffer[-BUFFER_LEN:]
session.expunge_all()
session.rollback()
time.sleep(SLEEP_TIME)
session.rollback()
session.close()
def replay_match(orig_match_id, mult=1.0, initial_wait=0.0):
session = Session()
# Retrieve the original match and prepare the new event list
# (already sorted by SQLAlchemy)
orig_match = session.query(Match).filter(Match.id == orig_match_id).one()
events = [((min(max(x.timestamp, orig_match.begin), orig_match.end) - orig_match.begin).total_seconds(), x)
for x in orig_match.events]
ref_time = 0.0
for i in xrange(len(events)):
delta = events[i][0] - ref_time
ref_time = events[i][0]
events[i] = (delta / mult, events[i][1])
# Replicate the original match
match = Match()
match.sched_begin = datetime.datetime.now() + datetime.timedelta(seconds=0.5 * initial_wait)
match.sched_end = match.sched_begin + multiply_timedelta(1.0 / mult, orig_match.sched_end - orig_match.sched_begin)
match.name = "Replay of \"%s\"" % (orig_match.name)
match.team_a = orig_match.team_a
match.team_b = orig_match.team_b
session.add(match)
# Add the advantage phases
phase = AdvantagePhase()
phase.match = match
phase.start_sec = 0
phase.advantage = 10
session.add(phase)
phase = AdvantagePhase()
phase.match = match
phase.start_sec = 30 * 60
phase.advantage = 5
session.add(phase)
phase = AdvantagePhase()
phase.match = match
phase.start_sec = 60 * 60
phase.advantage = 3
session.add(phase)
# Replicate the player_matches
for orig_pm in session.query(PlayerMatch).filter(PlayerMatch.match == orig_match):
pm = PlayerMatch()
pm.match = match
pm.player = orig_pm.player
pm.team = orig_pm.team
session.add(pm)
# Flush and commit
session.flush()
session.commit()
# Print match ID and start wait
print "> Feeding match with ID %d" % (match.id)
print "> Scheduled times: %s -- %s" % (match.sched_begin, match.sched_end)
print "> Waiting initial %f seconds..." % (initial_wait)
time.sleep(initial_wait)
# Set begin
match.begin = datetime.datetime.now()
print "> Match begins at %s" % (match.begin)
session.commit()
# Replay events
for wait_secs, orig_ev in events:
print "> Waiting %f seconds..." % (wait_secs)
time.sleep(wait_secs)
ev = Event()
ev.timestamp = datetime.datetime.now()
ev.match = match
ev.type = orig_ev.type
ev.source = orig_ev.source
ev.team = orig_ev.team
ev.player_a = orig_ev.player_a
ev.player_b = orig_ev.player_b
ev.red_team = orig_ev.red_team
ev.blue_team = orig_ev.blue_team
ev.phase = orig_ev.phase
print "> Pushing event of type %s and timestamp %s" % (ev.type, ev.timestamp)
session.add(ev)
ev.check_type()
session.commit()
# Set end
match.end = datetime.datetime.now()
print "> Match ends at %s" % (match.end)
session.commit()
print "> Finished feeding match with ID %d" % (match.id)
print "> Scheduled times were: %s -- %s" % (match.sched_begin, match.sched_end)
def listen_match(match_id, old_matches_id, post_url):
session = Session()
match = session.query(Match).filter(Match.id == match_id).one()
old_matches = session.query(Match).filter(Match.id.in_(old_matches_id)).all()
players = session.query(Player).all()
old_player_matches = session.query(PlayerMatch).filter(PlayerMatch.match_id.in_(old_matches_id)).all()
old_events = session.query(Event).filter(Event.match_id.in_(old_matches_id)).order_by(Event.timestamp).all()
old_stats_player_matches = session.query(StatsPlayerMatch).filter(StatsPlayerMatch.match_id.in_(old_matches_id)).all()
stats = Statistics(match, old_matches, players, old_player_matches, old_events, old_stats_player_matches)
last_event_id = 0
last_player_match_id = 0
last_timestamp = None
try:
while True:
session.rollback()
for player_match in session.query(PlayerMatch).filter(PlayerMatch.match == match).filter(PlayerMatch.id > last_player_match_id).order_by(PlayerMatch.id):
stats.new_player_match(player_match)
last_player_match_id = player_match.id
for event in session.query(Event).filter(Event.match == match).filter(Event.id > last_event_id).order_by(Event.id):
if last_timestamp is not None and event.timestamp <= last_timestamp:
print >> sys.stderr, "> Timestamp monotonicity error at %s!\n" % (event.timestamp)
#sys.exit(1)
stats.new_event(event)
last_timestamp = event.timestamp
last_event_id = event.id
# Send data to the web server
stats.generate_current_data()
data = stats.data
headers = {'content-type': 'application/json'}
json_data = json.dumps({'action': 'set', 'password': PASSWD, 'data': data})
print json_data
try:
r = requests.post(post_url, data=json_data, headers=headers)
print 'Request done', r.status_code
print r.text
except:
print >> sys.stderr, "Exception caught, continuing..."
traceback.print_exc()
time.sleep(SLEEP_TIME)
except KeyboardInterrupt:
pass
import sys
import time
from data import Session, Log, INTERESTING_FPS
COMMIT_FREQ = 1.0
def my_float(x):
if x == '':
return None
else:
return float(x)
if __name__ == '__main__':
session = Session()
retime = 'retime' in sys.argv[1:]
last_commit = time.time()
last_interesting = 0.0
try:
while True:
line = sys.stdin.readline()
if line == '':
break
data = [my_float(x) for x in line.strip().split(",")]
if retime:
data[0] = time.time()
timestamp = float(data[0])
log = Log.from_tuple(data)
if timestamp - last_interesting >= 1.0 / INTERESTING_FPS:
from data import Session, User, Status, Role, Post, Activity
from functools import wraps
from flask import Flask, render_template, Response, request, redirect, send_from_directory, url_for, Response
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from flask_login import LoginManager, login_required, login_user, current_user, logout_user
import werkzeug
app = Flask(__name__)
app.config["SECRET_KEY"] = "kek"
session = Session(autocommit=True, autoflush=True)
app.app_context()
login_manager = LoginManager()
login_manager.init_app(app)
class LoginForm(FlaskForm):
nickname = StringField('nickname')
password = PasswordField('password')
submit = SubmitField('submit')
@login_manager.user_loader
def load_user(id):
return session.query(User).filter(User.id == id).first()
@app.route("/logout")
def logout():
logout_user()
return redirect("/index")
with open(sys.argv[2], "r") as f:
for line in f:
line = line.strip()
if line.startswith("<row"):
node = etree.fromstring(line)
post_object = node.attrib
if post_object.get('PostTypeId') == "1":
tags = re.findall("\<(.*?)\>", post_object.get('Tags'))
for tag in tags:
s = "INSERT INTO poststags(PostsId, TagsId) VALUES (" + \
post_object.get('Id') + "," + str(tag_dict[tag]) +");"
print >> g, s
def tags_dict(path):
tags = {}
with open(path, "r") as f:
for line in f:
val= tuple(line.split())
if val[1] not in tags:
tags[val[1]]= int(val[0])
return tags
if __name__=="__main__":
s = Session()
# with open(sys.argv[1], "w") as f:
# get_tags(s, f)
tags = tags_dict(sys.argv[1])
with open(sys.argv[3], "w") as g:
update_poststags(tags, g)
self.ends.append(time)
def __str__(self):
status = ""
if self.running():
status = "(Now Playing)"
seconds = int(self.total_time().total_seconds())
if seconds > 0:
return "%s: %s seconds %s" % (self.performer.name,
seconds,
status)
else:
return "%s %s" % (self.performer.name,
status)
if __name__ == "__main__":
from data import Session
# Do an actual write.
session = Session()
dom = Performer(name="Dominic Rout", email="*****@*****.**", mobile = "07427549166")
al_g = Performer(name="Al Gordon", email="*****@*****.**", mobile = "1234123412312")
al_p = Performer(name="Al Pearson", email="*****@*****.**", mobile = "12341231123412312")
session.add(dom)
session.add(al_g)
session.add(al_p)
found_al = session.query(Performer).filter(Performer.name.like("%Al%")).first()
print(found_al)
def test_truncate_table():
with Session.begin() as s:
CrudTable().truncate_table(s)
with Session.begin() as s:
assert len(CrudTable.get_data(s)) == 0
def import_from_2012():
old_session = OldSession()
session = Session()
# Match and teams
match = Match()
match.name = "24 ore 2012"
first_team = session.query(Team).filter(Team.name == "Matematici").one()
second_team = session.query(Team).filter(Team.name == "Fisici").one()
match.team_a = first_team
match.team_b = second_team
# Team mapping
_team_map = {}
old_first_team = old_session.query(OldTeam).filter(OldTeam.name == "Matematici").one()
old_second_team = old_session.query(OldTeam).filter(OldTeam.name == "Fisici").one()
_team_map[old_first_team.id] = first_team
_team_map[old_second_team.id] = second_team
team_map = lambda x: _team_map[x.id]
# Player mapping
_player_map = {}
player_matches = []
found_player_id = set()
for old_player in old_session.query(OldPlayer).all():
player = Player.get_or_create(session, old_player.fname, old_player.lname, None)
_player_map[old_player.id] = player
player_match = PlayerMatch()
player_match.player = player
player_match.match = match
player_match.team = team_map(old_player.team)
player_matches.append(player_match)
player_map = lambda x: _player_map[x.id]
# Events
events = []
for old_event in old_session.query(OldEvent).order_by(OldEvent.timestamp).all():
if old_event.type == 'sched_begin':
match.sched_begin = old_event.timestamp
elif old_event.type == 'begin':
match.begin = old_event.timestamp
elif old_event.type == 'sched_end':
match.sched_end = old_event.timestamp
elif old_event.type == 'end':
match.end = old_event.timestamp
else:
event = Event()
event.match = match
event.timestamp = old_event.timestamp
event.source = Event.EV_SOURCE_MANUAL
event.type = old_event.type
if old_event.type in [Event.EV_TYPE_GOAL, Event.EV_TYPE_GOAL_UNDO]:
event.team = _team_map[int(old_event.param)]
elif old_event.type == Event.EV_TYPE_SWAP:
old_red_team_id, old_blue_team_id = map(int, old_event.param.split(','))
event.red_team = _team_map[old_red_team_id]
event.blue_team = _team_map[old_blue_team_id]
elif old_event.type == Event.EV_TYPE_CHANGE:
old_team_id, old_player_a_id, old_player_b_id = map(int, old_event.param.split(','))
event.team = _team_map[old_team_id]
event.player_a = _player_map[old_player_a_id]
event.player_b = _player_map[old_player_b_id]
found_player_id.add(event.player_a.id)
found_player_id.add(event.player_b.id)
else:
assert(False, "Command not supported")
events.append(event)
session.add(match)
for pm in player_matches:
if pm.player.id in found_player_id:
session.add(pm)
for ev in events:
session.add(ev)
assert(ev.check_type())
session.flush()
old_session.rollback()
session.commit()
def destroy_all():
session = Session()
Base.metadata.drop_all()
session.commit()
def listen_match(match_id, old_matches_id):
session = Session()
match = session.query(Match).filter(Match.id == match_id).one()
old_matches = session.query(Match).filter(Match.id.in_(old_matches_id)).all()
players = session.query(Player).all()
old_player_matches = session.query(PlayerMatch).filter(PlayerMatch.match_id.in_(old_matches_id)).all()
old_events = session.query(Event).filter(Event.match_id.in_(old_matches_id)).order_by(Event.timestamp).all()
old_stats_player_matches = session.query(StatsPlayerMatch).filter(StatsPlayerMatch.match_id.in_(old_matches_id)).all()
stats = Statistics(match, old_matches, players, old_player_matches, old_events, old_stats_player_matches)
last_event_id = 0
last_player_match_id = 0
last_timestamp = None
overlay_logic = OverlayLogic(stats)
last_display_event_id = 0
try:
while True:
session.rollback()
for player_match in session.query(PlayerMatch).filter(PlayerMatch.match == match).filter(PlayerMatch.id > last_player_match_id).order_by(PlayerMatch.id):
stats.new_player_match(player_match)
last_player_match_id = player_match.id
for event in session.query(Event).filter(Event.match == match).filter(Event.id > last_event_id).order_by(Event.id):
if last_timestamp is not None and event.timestamp <= last_timestamp:
print >> sys.stderr, "> Timestamp monotonicity error at %s!\n" % (event.timestamp)
#sys.exit(1)
stats.new_event(event)
overlay_logic.receive_game_event(event)
last_timestamp = event.timestamp
last_event_id = event.id
# Generate data
stats.generate_current_data()
data = stats.data
# FIXME
display_events = overlay_logic.get_display_events(last_display_event_id)
for e in display_events:
overlay_logic.ack_display_events_received(e.id)
time.sleep(SLEEP_TIME)
except KeyboardInterrupt:
pass
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
import sys
import time
from data import Session, Log
if __name__ == '__main__':
session = Session()
for log in session.query(Log):
session.delete(log)
session.commit()
"""
Get email addresses from the database and export them one per line
"""
import data.performer as performer
from data import Session
import sys
if len(sys.argv) != 2:
print "Please enter a filename to which to save the email addresses"
else:
print "Saving to %s" % sys.argv[1]
with open(sys.argv[1], "w") as f:
session = Session()
query = session.query(performer.Performer).all()
for _performer in query:
print >> f, _performer.email
