642 lines
22 KiB
Python
642 lines
22 KiB
Python
import datetime
|
|
import re
|
|
import xml.etree.ElementTree as etree
|
|
|
|
class Event:
|
|
def __init__(self, eventid, name, start_time=None, end_time=None,
|
|
organiser=None, courses=[], o_classes=[], runners=[],
|
|
card_dumps=[], fees=[]):
|
|
self.id = eventid
|
|
self.name = name
|
|
self.start_time = start_time
|
|
self.end_time = end_time
|
|
self.organiser = organiser
|
|
self.courses = courses
|
|
self.o_classes = o_classes
|
|
self.runners = runners
|
|
self.card_dumps = card_dumps
|
|
self.fees = fees
|
|
|
|
def __repr__(self):
|
|
return(f'id({self.id}), name({self.name}), organiser({self.organiser}), courses({self.courses}), o_classes({self.o_classes}), runners({self.runners})')
|
|
|
|
def add_course(self, *args):
|
|
for n in args:
|
|
self.courses.append(n)
|
|
|
|
def add_o_class(self, *args):
|
|
for n in args:
|
|
self.o_classes.append(n)
|
|
|
|
def add_runners(self, *args):
|
|
for n in args:
|
|
self.runners.append(n)
|
|
|
|
def add_fees(self, *args):
|
|
for n in args:
|
|
self.fees.append(n)
|
|
|
|
def get_course(self, name):
|
|
pass
|
|
|
|
def get_o_class(self, name):
|
|
pass
|
|
|
|
def get_runner(self, name):
|
|
pass
|
|
|
|
def read_xml_entries(self, xml_file):
|
|
self.add_runners(*runners_from_xml_entries(xml_file))
|
|
self.add_fees(*fees_from_xml_entries(xml_file))
|
|
|
|
# Må endres
|
|
def from_xml_entries(xml_file):
|
|
tree = ET.parse(xml_file)
|
|
root = tree.getroot()
|
|
|
|
url = '{http://www.orienteering.org/datastandard/3.0}'
|
|
event_el = root.find(f'./{url}Event')
|
|
event_id = int(event_el.find(f'./{url}Id').text)
|
|
name = event_el.find(f'./{url}Name').text
|
|
organiser = event_el.find(f'./{url}Organiser/{url}Name').text
|
|
|
|
start_ds = event_el.find(f'./{url}StartTime/{url}Date').text
|
|
start_ts = event_el.find(f'./{url}StartTime/{url}Time').text[:-1]
|
|
start_time = datetime.datetime.fromisoformat(f'{start_ds}T{start_ts}')
|
|
|
|
end_ds = event_el.find(f'./{url}EndTime/{url}Date').text
|
|
end_ts = event_el.find(f'./{url}EndTime/{url}Time').text[:-1]
|
|
end_time = datetime.datetime.fromisoformat(f'{end_ds}T{end_ts}')
|
|
|
|
runners = runners_from_xml_entries(xml_file)
|
|
fees = fees_from_xml_entries(xml_file)
|
|
|
|
return Event(event_id, name, organiser=organiser, runners=runners,
|
|
fees=fees, start_time=start_time, end_time=end_time)
|
|
|
|
def read_xml_courses(self, xml_file):
|
|
self.courses = courses_from_xml(xml_file)
|
|
|
|
def read_ttime_cnf(self, ttime_file):
|
|
self.add_course(*courses_from_ttime_conf(ttime_file))
|
|
self.add_o_class(*classes_from_ttime_conf(ttime_file, self.courses))
|
|
|
|
def read_ttime_db(self, ttime_file):
|
|
with open(ttime_file) as f:
|
|
data = f.readlines()
|
|
self.runners = [Runner.from_ttime_string(i) for i in data if i]
|
|
|
|
def read_mtr_file(self, mtr_file):
|
|
self.card_dumps = CardDump.list_from_mtr_f(mtr_file)
|
|
|
|
def get_result_xml(self):
|
|
root = ET.Element('ResultList')
|
|
root.set('xmlns', 'http://www.orienteering.org/datastandard/3.0')
|
|
root.set('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance')
|
|
root.set('iofVersion', '3.0')
|
|
root.set('createTime', datetime.datetime.now().isoformat(timespec='seconds'))
|
|
root.set('creator', 'oTime')
|
|
root.set('status', 'Complete')
|
|
tree = ET.ElementTree(root)
|
|
event = ET.SubElement(root, 'Event')
|
|
xml_child(event, 'Id', self.id)
|
|
xml_child(event, 'Name', self.name)
|
|
for i in self.o_classes:
|
|
print('Hmmmmmm')
|
|
# <ClassResult>
|
|
class_result = ET.SubElement(root, 'ClassResult')
|
|
# <Class>
|
|
t = ET.SubElement(class_result, 'Class')
|
|
xml_child(t, 'Name', i.name)
|
|
# <PersonResult>
|
|
runners_same_c = get_runners_in_class(self.runners, i)
|
|
runners_ranked = rank_runners(runners_same_c, i)
|
|
# Put the OK runners first and Active last
|
|
runners_sorted = [i for i in runners_same_c if i not in runners_ranked]
|
|
runners_ranked.extend(runners_sorted)
|
|
|
|
for n in runners_ranked:
|
|
person_result = ET.SubElement(class_result, 'PersonResult')
|
|
# <Person>
|
|
person = ET.SubElement(person_result, 'Person')
|
|
xml_child(person, 'Id', n.id)
|
|
# <Name>
|
|
name = ET.SubElement(person, 'Name')
|
|
xml_child(name, 'Family', n.last)
|
|
xml_child(name, 'Given', n.first)
|
|
# </Name>
|
|
# </Person>
|
|
# <Organisation>
|
|
org = ET.SubElement(person_result, 'Organisation')
|
|
xml_child(org, 'Id', n.club_id)
|
|
xml_child(org, 'Name', n.club)
|
|
country = ET.SubElement(org, 'Country')
|
|
# TODO: hent land fra løperobjektet
|
|
country.text = 'Norway'
|
|
country.set('code', 'NOR')
|
|
# </Organisation>
|
|
# <Result>
|
|
result = ET.SubElement(person_result, 'Result')
|
|
|
|
# TODO: Dette bør skrives om til å bruke Runner metoder så mye som mulig.
|
|
if hasattr(n, 'card_r') and len(n.card_r.splits) > 2:
|
|
xml_child(result, 'StartTime', n.card_r.s_time.isoformat())
|
|
xml_child(result, 'FinishTime', n.card_r.f_time.isoformat())
|
|
xml_child(result, 'Time', n.totaltime())
|
|
if n.status() == 'OK':
|
|
# <TimeBehind>
|
|
xml_child(result, 'TimeBehind', n.totaltime() - runners_ranked[0].totaltime())
|
|
# </TimeBehind>
|
|
xml_child(result, 'Position', n.rank(self.runners))
|
|
xml_child(result, 'Status', n.status())
|
|
# <SplitTime>
|
|
# TODO: ta utgangspunkt i løypa, ikke det brikka har stempla
|
|
for code, split in zip(n.card_r.controls, n.card_r.splits):
|
|
st = ET.SubElement(result, 'SplitTime')
|
|
xml_child(st, 'ControlCode', code)
|
|
xml_child(st, 'Time', split)
|
|
if code == n.res_codes()[-1]:
|
|
break
|
|
# </SplitTime>
|
|
elif n.status() == 'Disqualified':
|
|
xml_child(result, 'Status', n.status())
|
|
for code, split in zip(n.res_codes(), n.res_splits()):
|
|
st = ET.SubElement(result, 'SplitTime')
|
|
xml_child(st, 'ControlCode', code)
|
|
if split is not None:
|
|
xml_child(st, 'Time', split)
|
|
else:
|
|
xml_child(result, 'Status', n.status())
|
|
else:
|
|
xml_child(result, 'Status', n.status())
|
|
# </Result>
|
|
# </PersonResult>
|
|
# </Class>
|
|
ET.indent(root, space=' ', level=0)
|
|
return tree
|
|
|
|
# The runner object stores all the data specific to a runner.
|
|
class Runner:
|
|
def __init__(self, runner_id: int, first: str, last: str, club=None, club_id=None,
|
|
country=None, card_id=None, o_class_str=None, o_class=None,
|
|
fork=0, start_time=None, fee_id=None, fee=None):
|
|
self.id = runner_id
|
|
self.first = first
|
|
self.last = last
|
|
self.club = club
|
|
self.club_id = club_id
|
|
self.country = country
|
|
self.card_id = card_id
|
|
self.o_class = o_class
|
|
self.fork = fork
|
|
self.start_time = start_time
|
|
self.fee_id = fee_id
|
|
|
|
def __repr__(self):
|
|
return(f'name({self.fullname()})')
|
|
|
|
def from_ttime_string(ttime_db_line):
|
|
# Reads 1 line of a ttime db
|
|
#https://web.archive.org/web/20191229124046/http://wiki.ttime.no/index.php/Developer
|
|
runner_data = ttime_db_line.split(';')
|
|
eventorid = runner_data[0]
|
|
country = ''
|
|
name = runner_data[2].split(',')
|
|
try:
|
|
first = name[1].strip()
|
|
except:
|
|
first = ''
|
|
last = name[0]
|
|
try:
|
|
club = runner_data[4]
|
|
except:
|
|
club = ''
|
|
try:
|
|
card = int(runner_data[6])
|
|
except:
|
|
card = 0
|
|
try:
|
|
o_class = runner_data[3]
|
|
except:
|
|
o_class = ''
|
|
options = runner_data[5].split(',')
|
|
try:
|
|
club_id = options[options.index('A')+3]
|
|
except:
|
|
club_id = 0
|
|
try:
|
|
start_time = options[options.index('U')+1]
|
|
except:
|
|
start_time = None
|
|
return Runner(eventorid, first, last, club=club, club_id=club_id,
|
|
country=country, card_id=card, o_class=o_class, start_time=start_time)
|
|
|
|
def fullname(self):
|
|
return '{} {}'.format(self.first, self.last)
|
|
|
|
def check_codes(self):
|
|
return contains(self.res_codes(), self.card_r.controls)
|
|
|
|
def totaltime(self):
|
|
f_control = self.res_codes()[-1]
|
|
try:
|
|
index = self.card_r.controls.index(f_control)
|
|
return self.card_r.splits[index]
|
|
except:
|
|
return 0
|
|
|
|
def status(self):
|
|
if hasattr(self, 'card_r') is False or self.o_class is None:
|
|
return 'Active'
|
|
elif self.check_codes():
|
|
return 'OK'
|
|
elif self.check_codes() is False:
|
|
return 'Disqualified'
|
|
|
|
# TODO: må forbedres
|
|
def rank(self, allrunners):
|
|
c_ranked = rank_runners(allrunners, self.o_class)
|
|
try:
|
|
return c_ranked.index(self) + 1
|
|
except ValueError:
|
|
return None
|
|
|
|
def res_codes(self):
|
|
if self.o_class.course.forked is False:
|
|
return self.o_class.course.codes
|
|
else:
|
|
return self.o_class.course.variations[self.fork]
|
|
|
|
# TODO: Mange bugs med løyper som har samme post flere ganger
|
|
# Used for making result files and tables
|
|
def res_splits(self):
|
|
if self.status() == 'OK':
|
|
splits_cpy = self.card_r.splits.copy()
|
|
for control in self.card_r.controls:
|
|
if control not in self.res_codes():
|
|
index = self.card_r.controls.index(control)
|
|
split = self.card_r.splits[index]
|
|
splits_cpy.remove(split)
|
|
return splits_cpy
|
|
|
|
else:
|
|
splits_cpy = self.card_r.splits.copy()
|
|
for control in self.card_r.controls:
|
|
if control not in self.res_codes():
|
|
index = self.card_r.controls.index(control)
|
|
split = self.card_r.splits[index]
|
|
try:
|
|
splits_cpy.remove(split)
|
|
except Exception:
|
|
print('aaaaaa')
|
|
|
|
|
|
punches = self.card_r.controls.copy()
|
|
splits = []
|
|
for code in self.res_codes():
|
|
if punches[0] == code:
|
|
splits.append(splits_cpy[0])
|
|
splits_cpy.pop(0)
|
|
punches.pop(0)
|
|
continue
|
|
else:
|
|
splits.append(None)
|
|
return splits
|
|
|
|
def asdict(self):
|
|
return {
|
|
'id': self.id,
|
|
'first': self.first,
|
|
'last': self.last,
|
|
'club_id': self.club_id,
|
|
'club': self.club,
|
|
'country': self.country,
|
|
'card': self.card,
|
|
'o_class_str': self.o_class_str,
|
|
'fork' : self.fork,
|
|
'start_time': self.start_time,
|
|
'fee_id': self.fee_id
|
|
}
|
|
|
|
|
|
class CardDump:
|
|
def __init__(self, card, controls, splits, read_time, s_time, f_time):
|
|
self.card = card
|
|
self.controls = controls
|
|
self.splits = splits
|
|
self.read_time = read_time
|
|
self.s_time = s_time
|
|
self.f_time = f_time
|
|
|
|
def __repr__(self):
|
|
return f'card({self.card}) controls({self.controls}) splits({self.splits})'
|
|
|
|
def from_mtr_bytes(datamsg):
|
|
card = int.from_bytes(datamsg[20:23], 'little')
|
|
|
|
#Extract codes and splits:
|
|
controls = []
|
|
splits = []
|
|
splits_offset = 26
|
|
code_numbytes = 1
|
|
time_numbytes = 2
|
|
split_numbytes = code_numbytes + time_numbytes
|
|
for split_index in range(50):
|
|
code_offset = splits_offset + split_index * split_numbytes
|
|
time_offset = code_offset + code_numbytes
|
|
code = int.from_bytes(datamsg[code_offset:code_offset+code_numbytes], 'little')
|
|
time = int.from_bytes(datamsg[time_offset:time_offset+time_numbytes], 'little')
|
|
if code != 0:
|
|
controls.append(code)
|
|
splits.append(time)
|
|
|
|
# Extract start time:
|
|
year = int.from_bytes(datamsg[8:9], 'little')
|
|
month = int.from_bytes(datamsg[9:10], 'little')
|
|
day = int.from_bytes(datamsg[10:11], 'little')
|
|
hours = int.from_bytes(datamsg[11:12], 'little')
|
|
minutes = int.from_bytes(datamsg[12:13], 'little')
|
|
seconds = int.from_bytes(datamsg[13:14], 'little')
|
|
milliseconds = int.from_bytes(datamsg[14:16], 'little')
|
|
|
|
read_time = datetime.datetime(year, month, day, hours, minutes, seconds, milliseconds)
|
|
if len(controls) > 2:
|
|
s_time = read_time - datetime.timedelta(seconds=splits[-1])
|
|
f_time = read_time - (datetime.timedelta(seconds=splits[-1]) + datetime.timedelta(seconds=splits[-2]))
|
|
else:
|
|
s_time = read_time
|
|
f_time = read_time
|
|
|
|
return(CardDump(card, controls, splits, read_time, s_time, f_time))
|
|
|
|
def list_from_mtr_f(mtr_file):
|
|
with open(mtr_file) as f:
|
|
data = [i.replace('"','').split(',') for i in f.readlines()]
|
|
print(data)
|
|
cards = []
|
|
# hver rad er brikkenummer med tilhørende info
|
|
for row in data:
|
|
controls = []
|
|
splits = []
|
|
# postkodene kommer på oddetall fra og med den 11. De blir hevet inn i controls
|
|
for item in row[11::2]:
|
|
if item == '250':
|
|
controls.append(int(item))
|
|
break
|
|
elif item == '000':
|
|
break
|
|
else:
|
|
controls.append(int(item))
|
|
# strekktidene kommer på partall fra og med den 12. De blir hevet i splits.
|
|
for item in row[12::2]:
|
|
if item == '00000':
|
|
break
|
|
else:
|
|
splits.append(int(item))
|
|
# looper gjonnom løperobjektene og legger til poster og strekktider + start og sluttid
|
|
# usikker på om dette er riktig klokeslett
|
|
tl = row[5].split(' ')
|
|
tl[0] = tl[0].split('.')
|
|
tl[0][2] = '20' + tl[0][2]
|
|
tl[0] = list(map(int, tl[0]))
|
|
tl[1] = tl[1].split(':')
|
|
tl[1][2] = float(tl[1][2])
|
|
tl[1] = list(map(int, tl[1]))
|
|
read_time = datetime.datetime(tl[0][2], tl[0][1], tl[0][0], tl[1][0], tl[1][1], tl[1][2])
|
|
if len(controls) > 2 and len(splits) > 2:
|
|
s_time = read_time - datetime.timedelta(seconds=splits[-1])
|
|
f_time = read_time - (datetime.timedelta(seconds=splits[-1]) + datetime.timedelta(seconds=splits[-2]))
|
|
else:
|
|
s_time = read_time
|
|
f_time = read_time
|
|
cards.append(CardDump(int(row[6]), controls, splits, read_time, s_time, f_time))
|
|
return cards
|
|
|
|
def asdict(self):
|
|
return {
|
|
'card': self.card,
|
|
'controls': self.controls,
|
|
'splits': self.splits,
|
|
'read_time': self.read_time.isoformat(),
|
|
's_time': self.s_time.isoformat(),
|
|
'f_time': self.f_time.isoformat()
|
|
}
|
|
|
|
# Stored in Event.courses
|
|
class Course:
|
|
def __init__(self, name, codes, forked=False, variations=None):
|
|
self.name = name
|
|
self.codes = codes
|
|
self.forked = forked
|
|
# Variations is a list
|
|
self.variations = variations
|
|
|
|
def __repr__(self):
|
|
return f'name({self.name})'
|
|
|
|
def asdict(self):
|
|
return {
|
|
'name': self.name,
|
|
'codes': self.codes,
|
|
'forked': self.forked,
|
|
'variations': self.variations
|
|
}
|
|
|
|
# Stored in Event.o_classes
|
|
class OClass:
|
|
def __init__(self, name, course_str, course):
|
|
self.name = name
|
|
self.course = course
|
|
|
|
def __repr__(self):
|
|
return f'name({self.name})'
|
|
|
|
def asdict(self):
|
|
return {
|
|
'name': self.name,
|
|
'course_str': self.course_str
|
|
}
|
|
|
|
class Fee:
|
|
def __init__(self, fee_id, name, currency, amount, from_birth_date=None,
|
|
to_birth_date=None):
|
|
self.id = fee_id
|
|
self.name = name
|
|
self.currency = currency
|
|
self.amount = amount
|
|
self.from_birth_date = from_birth_date
|
|
self.to_birth_date = to_birth_date
|
|
|
|
def asdict(self):
|
|
return {
|
|
'id': self.id,
|
|
'name': self.name,
|
|
'currency': self.currency,
|
|
'amount': self.amount,
|
|
'from_birth_date': self.from_birth_date,
|
|
'to_birth_date': self.to_birth_date
|
|
}
|
|
|
|
# TODO: Take string instead of file.
|
|
def courses_from_ttime_conf(ttime_file):
|
|
with open(ttime_file, 'r') as f:
|
|
data = f.readlines()
|
|
courses = []
|
|
for line in data:
|
|
if '-codes' in line:
|
|
code_list = re.search(r'(?<=\")(.*?)(?=\")', line).group().split(';')
|
|
loops = 0
|
|
for n in code_list:
|
|
n = n.split(',')
|
|
loops += 1
|
|
n = list(map(int, n))
|
|
courses.append(Course('course_'+str(loops), n))
|
|
return courses
|
|
|
|
def classes_from_ttime_conf(ttime_file, courses):
|
|
with open(ttime_file, 'r') as f:
|
|
data = f.readlines()
|
|
o_classes = []
|
|
for line in data:
|
|
if '-courses' in line:
|
|
raw_courselist = re.search(r'(?<=\")(.*?)(?=\")', line).group().split(';')
|
|
loops = 0
|
|
for n in raw_courselist:
|
|
split = n.split(',')
|
|
for i in split:
|
|
o_classes.append(OClass(i, courses[loops].name, courses[loops]))
|
|
loops += 1
|
|
return o_classes
|
|
|
|
def runners_from_xml_entries(xml_file):
|
|
tree = ET.parse(xml_file)
|
|
root = tree.getroot()
|
|
|
|
url = '{http://www.orienteering.org/datastandard/3.0}'
|
|
runners = []
|
|
person_entries = root.findall(f'./{url}PersonEntry')
|
|
for p_entry in person_entries:
|
|
|
|
rid = p_entry[1][0].text
|
|
|
|
person = p_entry.find(f'./{url}Person')
|
|
name = person.find(f'./{url}Name')
|
|
first = name.find(f'./{url}Given').text
|
|
last = name.find(f'./{url}Family').text
|
|
|
|
organisation = p_entry.find(f'./{url}Organisation')
|
|
if organisation is not None:
|
|
club_id = organisation.find(f'./{url}Id').text
|
|
club_name = organisation.find(f'./{url}Name').text
|
|
club_name_short = organisation.find(f'./{url}ShortName').text
|
|
country = organisation.find(f'./{url}Country').attrib['code']
|
|
else:
|
|
club_id = club_name = club_name_short = country = None
|
|
|
|
class_el = p_entry.find(f'./{url}Class')
|
|
class_str = class_el.find(f'./{url}Name').text
|
|
|
|
fee_id = int(p_entry.find(f'./{url}AssignedFee/{url}Fee/{url}Id').text)
|
|
|
|
try:
|
|
card = int(p_entry.find(f'./{url}ControlCard').text)
|
|
except AttributeError:
|
|
card = None
|
|
|
|
start_time = None
|
|
runners.append(Runner(rid, first, last, club=club_name, club_id=club_id,
|
|
country=country,card=card, o_class_str=class_str,
|
|
start_time=start_time, fee_id=fee_id))
|
|
return runners
|
|
|
|
def fees_from_xml_entries(xml_file):
|
|
tree = ET.parse(xml_file)
|
|
root = tree.getroot()
|
|
|
|
url = '{http://www.orienteering.org/datastandard/3.0}'
|
|
allfees = root.findall(f'.//{url}Fee')
|
|
added_ids = []
|
|
fee_objs = []
|
|
for fee in allfees:
|
|
f_id = int(fee.find(f'./{url}Id').text)
|
|
if f_id not in added_ids:
|
|
added_ids.append(f_id)
|
|
|
|
fee_id = f_id
|
|
name = fee.find(f'./{url}Name').text
|
|
currency = fee.find(f'./{url}Amount').attrib['currency']
|
|
amount = int(fee.find(f'./{url}Amount').text)
|
|
try:
|
|
from_birth_date = fee.find(f'./{url}FromDateOfBirth').text
|
|
except AttributeError:
|
|
from_birth_date = None
|
|
try:
|
|
to_birth_date = fee.find(f'./{url}ToDateOfBirth').text
|
|
except AttributeError:
|
|
to_birth_date = None
|
|
|
|
fee_objs.append(Fee(fee_id, name, currency, amount,
|
|
from_birth_date=from_birth_date, to_birth_date=to_birth_date))
|
|
return fee_objs
|
|
|
|
def courses_from_xml(xml_file):
|
|
tree = ET.parse(xml_file)
|
|
root = tree.getroot()
|
|
|
|
url = '{http://www.orienteering.org/datastandard/3.0}'
|
|
allcourses = root.findall(f'.//{url}Course')
|
|
courseobjs = []
|
|
for c in allcourses:
|
|
name = c.find(f'./{url}Name').text
|
|
controls = []
|
|
allcontrols = c.findall(f'./{url}CourseControl')
|
|
for n in allcontrols:
|
|
controls.append(n.find(f'./{url}Control').text)
|
|
controls.remove('STA1')
|
|
controls.remove('FIN1')
|
|
controls = [int(l) for l in controls]
|
|
courseobjs.append(Course(name, controls))
|
|
return courseobjs
|
|
|
|
# Checks if small list is in big list
|
|
def contains(small, big):
|
|
valid = True
|
|
mark = 0
|
|
map_bl = []
|
|
for i in small:
|
|
for n, control in enumerate(big[mark:]):
|
|
if i == control:
|
|
mark += n
|
|
map_bl.append(mark)
|
|
break
|
|
else:
|
|
valid = False
|
|
if valid:
|
|
return map_bl
|
|
else:
|
|
return False
|
|
|
|
|
|
def get_runners_in_class(runners, o_class):
|
|
# Filters out runner objects that dont have the correct o_class
|
|
list_filtrd = []
|
|
for i in runners:
|
|
if i.o_class == o_class:
|
|
list_filtrd.append(i)
|
|
return list_filtrd
|
|
|
|
|
|
def rank_runners(allrunners, o_class):
|
|
runners = get_runners_in_class(allrunners, o_class)
|
|
runners_ranked = []
|
|
for i in runners:
|
|
if i.status() == 'OK':
|
|
runners_ranked.append(i)
|
|
runners_ranked.sort(key=lambda x: x.totaltime())
|
|
return runners_ranked
|
|
|
|
|
|
# Used to make creating xml files easier
|
|
def xml_child(parent, tag, content):
|
|
e = ET.SubElement(parent, tag)
|
|
e.text = str(content) |