def generate_magazines():
totalMags = 0
magspath = location.docroot + "magazines/"
picpath = magspath + "pix/"
bubbles = defaultdict(list)
root = ET.parse(location.dbroot + 'magazines.xml').getroot()
for mag in root:
if mag.tag == "introduction":
#introduction = mag.text
introduction = ET.tostring(mag)
continue
if mag.get('private'): continue # skip stuff not ready for publication
if mag.get('own') == "no":
continue # skip stuff that I don't actually have
if mag.get('nocover'):
continue # skip stuff if elton not on the cover page
if mag.tag == "fanmagazine":
continue # fan magazines will be done some other way
pic = mag.get('pic')
if pic == None: continue # TBD: we should complain about missing pic
totalMags += 1
rows = []
picfile = picpath + pic
try:
(type, width, height) = getImageInfo(picfile)
allPicFiles.remove(pic)
imageTD = TD(dclass="single_sleeve",
content=IMG(dclass="sleeve",
src="pix/" + pic,
width=width,
height=height))
if width != 200: print "bad width for", pic
except:
try:
print "cannot find picture for", mag.get('title'), mag.get(
'date'), ":", pic
except:
print "cannot find picture for", mag.get('date')
titletext = mag.get('title')
rows.append(DIV(dclass="important left", content=U(B(titletext))))
issuetext = mag.get('date')
year = addYear(issuetext)
date = issuetext.split('-')
if len(date) > 1:
if date[1] in monthAbbreviation:
date[1] = monthAbbreviation[date[1]]
if len(date) == 2:
issuetext = date[1] + " " + date[0]
if len(date) == 3:
issuetext = date[1] + " " + date[2] + ", " + date[0]
if (mag.get('issue') != None):
if is_number(mag.get('issue')):
issuetext = issuetext + ' (#' + mag.get('issue') + ')'
else:
issuetext = issuetext + ' (' + mag.get('issue') + ')'
rows.append(DIV(dclass="left", content="Issue Date: " + B(issuetext)))
rows.append(
DIV(dclass="left", content="Country: " + B(mag.get('country'))))
color = "blue"
#if mag.get('own') != None : color = "yellow"
textTD = TD(dclass="top", content="".join(rows))
bubbles[year].append(
DIV(dclass="bubble " + color, content=TABLE(TR(imageTD + textTD))))
# this javascript gets added to each mags html file
# it is the response to load a new page when a selection is made
yearScript = '''
<script type="text/javascript">
function showYear(selector,firstyear) {
year = selector.options[selector.selectedIndex].value
if (year == firstyear) year = ""
newurl = "index" + year + ".html";
document.location=newurl;
}
</script>
'''
# divide all the magazines into sepatate index files sorted by year
magroot = location.docroot + "magazines/"
prevlink = None
for y in allYears:
mag_index_text = templates.getMagazineIndex().substitute(
EXTRA_HEADER=yearScript,
DESCR=DIV(dclass="description", content=introduction),
BOOKS=DIV(dclass="full_width", content="\n\n".join(bubbles[y])),
NAVBAR=yearSelector(y),
)
suffix = str(y)
if y == allYears[0]: suffix = ""
with open(magroot + "index" + suffix + ".html", "w") as magindex:
magindex.write(mag_index_text.encode('UTF-8'))
return totalMags
def generate_books():
totalBooks = 0
totalPages = 0
bookspath = location.docroot + "books/"
picpath = bookspath + "pix/"
bubbles = []
root = ET.parse(location.dbroot + 'books.xml').getroot()
for book in root:
if book.tag == "introduction":
introduction = book.text
continue
pages = int(book.get('pages'))
totalPages += pages
totalBooks += 1
if book.get('private'): continue
rows = []
pic = book.get('pic')
picfile = picpath + pic
try:
(type, width, height) = getImageInfo(picfile)
imageTD = TD(dclass="single_sleeve",
content=IMG(dclass="sleeve",
src="pix/" + pic,
width=width,
height=height))
if width != 200: print "bad width for", pic
except IOError:
print "cannot find picture for", book.get('title'), ":", pic
titletext = book.get('title')
rows.append(
DIV(dclass="important left", content="Title: " + U(B(titletext))))
if book.get('author'):
authortext = book.get('author')
rows.append(DIV(dclass="left", content="Author: " + B(authortext)))
rows.append(DIV(dclass="left", content="Year: " + B(book.get('year'))))
if book.get('publisher'):
pubtext = book.get('publisher')
rows.append(DIV(dclass="left", content="publisher: " + B(pubtext)))
if book.get('ISBN'):
rows.append(
DIV(dclass="left", content="ISBN: " + B(book.get('ISBN'))))
if book.get('country'):
rows.append(
DIV(dclass="left",
content="Country: " + B(book.get('country'))))
rows.append(DIV(dclass="left", content="pages: " + B(str(pages))))
rows.append(
DIV(dclass="left", content="binding: " + B(book.get('format'))))
if book.get('amazon'):
rows.append(
DIV(dclass="left",
content=templates.getAmazonButton(book.get('amazon'))))
d = book.find('description')
if d is not None:
if d.get('source'):
rows.append(
DIV(dclass="left small padded3 bold",
content="[description text from " + d.get('source') +
":]"))
rows.append(DIV(dclass="left", content=ET.tostring(element=d)))
textTD = TD(dclass="top", content="".join(rows))
bubbles.append(
DIV(dclass="bubble", content=TABLE(TR(imageTD + textTD))))
#index_text = templates.getBooksIndex().substitute(
# DESCR = DIV(dclass="description", content=introduction),
# BOOKS = DIV(dclass="full_width", content="\n\n".join(bubbles)),
#)
# figure out how many index pages we need to create
max_rows_per_index = 14
total_index_pages = len(bubbles) / max_rows_per_index
if len(bubbles) % max_rows_per_index > 0: total_index_pages += 1
# chop away at the bubbles list, moving them into the current index page
bookroot = location.docroot + "books/"
for page in range(total_index_pages):
my_rows = bubbles[:
max_rows_per_index] # grab the books that go into this index page
del bubbles[:max_rows_per_index] # clean up as we go
book_index_text = templates.getBooksIndex().substitute(
EXTRA_HEADER="",
DESCR=DIV(dclass="description", content=introduction),
BOOKS=DIV(dclass="full_width", content="\n\n".join(my_rows)),
#NAVBAR = DIV(content=DIV(content=" ".join(navDots))),
NAVBAR=templates.getDotsDiv(page, total_index_pages),
)
suffix = str(page + 1)
if page == 0: suffix = ""
with open(bookroot + "index" + suffix + ".html", "w") as bookindex:
bookindex.write(book_index_text.encode('UTF-8'))
return totalBooks
def generate_session_albums():
totalAlbums = 0
loadTracks(location.dbroot + "album_tracks.xml")
sessionroot = location.docroot + "albums/sessions/"
picroot = sessionroot + "pix/"
root = XML.parse(location.dbroot + 'sessionwork.xml').getroot()
totalrecords = 0
description = root.find('description')
#description = description.text
description = XML.tostring(description)
index_rows = []
songrows = []
songrows.append(
TR(
TD(B(U("released"))) + TD(B(U("title"))) +
TD(B(U("original artist")))))
for song in root.findall('listing/song'):
year = song.get('date')[:4]
month = song.get('date')[5:7]
month = monthAbbreviation[month]
eltonvocals = song.get('elton', default="lead vocals")
eltonvocals = " [" + eltonvocals + "]"
songrow = TR(
TD(month + " " + year) +
TD(B(U(song.get('title'))) + eltonvocals) + TD(song.get('artist')))
songrows.append(songrow)
songtable = DIV(dclass="bubble",
content=TABLE(content="\n".join(songrows),
dclass="left small"))
description += songtable
for category in root.findall('category'):
if category.get('private'): continue
format = category.get('format')
categoryname = category.get('format')
for issue in category:
if issue.get('private'): continue
#if issue.get('pic') == None: continue
totalrecords += 1
title = issue.get('title')
if title == None: title = ""
if format == "7": title = "7-inch single"
if format == "CD5": title = "CD single"
catalog = issue.get('catalog')
if catalog == None:
print "no catalog for", title
continue
pic = issue.get('pic')
if pic == None:
picTD = TD(dclass="missing_sleeve", content="[no sleeve]")
else:
picfile = picroot + pic
if os.path.isfile(picfile):
(type, width, height) = getImageInfo(picfile)
picTD = TD(dclass="single_sleeve",
content=IMG(dclass="sleeve",
src="pix/" + pic,
width=width,
height=height))
else:
picTD = TD(dclass="missing_sleeve",
content="[photo not available]")
print "ERROR: can't find session picture:", title, catalog
year = issue.get('year', default="")
if len(year): year = " (" + year[:4] + ")"
trackrows = []
for track in issue.findall('track'):
if track.get('artist') == "anonymous":
trackrows.append(
LI(dclass="anonymous", content=track.get('title')))
else:
trackrows.append(
LI(dclass="track", content=linkTrack(track)))
reftracks = []
for element in issue:
if element.tag == 'tracks':
reftracks = reftracks + alltracks[element.get('id')]
for track in reftracks:
trackrows.append(LI(dclass="track", content=linkTrack(track)))
prefix = issue.get('discs', "")
iconfile = "/pix/" + prefix + format + ".gif"
(type, width, height) = getImageInfo(location.docroot + iconfile)
icon = IMG(dclass="padded10",
src=iconfile,
width=width,
height=height)
notes = ""
for note in issue.findall('note'):
notes += BR() + note.text
tracktable = OL("\n".join(trackrows))
title = DIV(dclass="large bold", content=title)
detailsText = icon + title + catalog + year + notes
detailsTD = TD(dclass="guest_text",
content=detailsText + BR() + tracktable)
session_issue = TABLE(TR(picTD + detailsTD))
index_rows.append(DIV(dclass="bubble", content=session_issue))
session_index_text = templates.getSessionIndex().substitute(
TITLE=DIV(dclass="heading padded10",
content="Elton John as a Session Musician"),
DESCR=DIV(dclass="description", content=description),
ALBUMS=DIV(dclass="full_width", content="\n\n".join(index_rows)),
)
with open(sessionroot + "index.html", "w") as sessionindex:
sessionindex.write(session_index_text.encode('latin-1'))
return totalrecords
def parse_standard_albums():
totalAlbums = 0
loadTracks(location.dbroot + "album_tracks.xml")
albumroot = location.docroot + "albums/standard/"
picroot = albumroot + "pix/"
root = ET.parse(location.dbroot + 'category_albums.xml').getroot()
##decodedroot = ET.tostring(root)
##root2 = ET.fromstring(decodedroot)
### establish prev/next icons
for category in root:
if category.tag == 'description':
pageDescription = DIV(dclass="description", content=category.text)
continue
prevalbum = None
for album in category:
album.set('previcon', "")
album.set('nexticon', "")
if prevalbum != None:
prevpic = IMG(src="/pix/left_arrow.gif",
border="0",
title=prevalbum.get('title'))
nextpic = IMG(src="/pix/right_arrow.gif",
border="0",
title=album.get('title'))
prevalbum.set('nexticon',
A(href=album.get('id') + ".html",
content=nextpic)) # forward link
album.set('previcon',
A(href=prevalbum.get('id') + ".html",
content=prevpic)) # backward link
prevalbum = album
styles = []
catThumbs = {}
categories = []
for category in root:
if category.tag == 'description': continue
### create the CSS style & index matrix for all the sprites in this category
thumbs = []
for album in category:
id = album.get('id')
XY = '-' + album.get('spriteX') + 'px ' + '-' + album.get(
'spriteY') + 'px'
imagecss = "img#" + id + "{ width:50px; height:50px; background:url(sprite.jpg) " + XY + ";}"
styles.append(
imagecss) # each album gets an icon in their category
thumbs.append(minilink(album))
categories.append(category.get('name'))
catThumbs[category.get('name')] = DIV(dclass="thumbnails",
content=" ".join(thumbs))
### create an HMTL page for each album
for album in category:
totalAlbums += 1
albumnotes = []
versions = []
title = album.get('title')
for element in album:
if element.tag == 'see': continue
if element.tag == 'note':
albumnotes.append(element.text)
continue
# otherwise it's a version
tracks = []
versionNotes = []
version = element
name = version.get('name')
if name == None: name = ""
year = '(' + version.get('year')[:4] + ')'
amazonID = version.get('amazon')
if amazonID: amazon = templates.getAmazonButton(amazonID)
else: amazon = ""
picname = version.get('pic')
if not os.path.isfile(picroot + picname):
print "error no pic", picname
(type, width, height) = getImageInfo(picroot + picname)
image = IMG(dclass="sleeve",
src="pix/" + picname,
width=width,
height=height)
picTD = TD(dclass="single_sleeve", content=image)
for element in version:
if element.tag == 'tracks':
tracks = tracks + alltracks[element.get('id')]
elif element.tag == 'section':
tracks = tracks + [element]
elif element.tag == 'note':
versionNotes.append(element.text)
else:
print "bad tag", element.tag
trackrows = []
trackrows.append(
TR(
TD(dclass="single_details",
colspan=2,
content=" ".join([name, year]))))
for note in versionNotes:
trackrows.append(
TR(TD(dclass="note", colspan=2, content=note)))
trackrows.append(
TR(TD(dclass="amazon", colspan=2, content=amazon)))
for track in tracks:
if track.tag == 'section':
trackrows.append(
TR(
TD(colspan=2,
dclass="tracksection",
content=track.get('title'))))
continue
tracktime = TD(dclass="time", content=track.get('length'))
tracktext = TD(dclass="track", content=linkTrack(track))
trackrows.append(TR(tracktime + tracktext))
tracktable = TABLE("\n".join(trackrows))
detailsTD = TD(tracktable)
versiontable = TABLE(dclass="single_issue",
content=TR(picTD + detailsTD))
versions.append(DIV(dclass="bubble", content=versiontable))
page_template = templates.getStandardAlbumTemplate(title)
album_text = page_template.substitute(
NEXTICON=album.get('nexticon'),
PREVICON=album.get('previcon'),
ALBUM_TITLE=DIV(dclass="heading", content=U(title)),
ALBUM_NOTES=DIV(dclass="subheading",
content="<br/>".join(albumnotes)),
VERSIONS="\n".join(versions))
target = album.get('id') + ".html"
with open(albumroot + target, "w") as albumfile:
albumfile.write(album_text.encode('UTF-8'))
# end album
#end category
catDivs = []
for category in categories:
catDivs.append(
DIV(dclass="bubble",
content=DIV(dclass="heading", content=category + ':') +
catThumbs[category]))
albumCSS = STYLE(content="\n".join(styles))
index_template = templates.getStandardIndexTemplate()
index_text = index_template.substitute(
EXTRA_STYLE=albumCSS,
CONTENT=pageDescription + "".join(catDivs),
)
with open(albumroot + "index.html", "w") as indexfile:
indexfile.write(index_text.encode('UTF-8'))
return totalAlbums
def parse_import_cds(per_page):
count = 0
imports = ET.parse(location.dbroot + 'import_cds.xml').getroot()
importpath = location.docroot + "albums/unauthorized/"
picpath = importpath + "pix/"
introduction = ""
bubbles = []
for cd in imports:
if cd.tag == 'introduction':
introduction = cd.text
continue
if cd.get('private'): continue
count += 1
# establish the left TD with a cover scan
pic = cd.get('pic')
if not pic: raise Exception("missing import pic for " + title)
picfile = picpath + pic
(type, width, height) = getImageInfo(picfile)
img = IMG(dclass="sleeve",
src="pix/" + pic,
width=width,
height=height,
alt="scan of sleeve",
title="scan of sleeve")
picTD = TD(dclass="single_sleeve", content=img)
# establish the right TD with all the text (as separate table rows)
textRows = []
textRows.append(
TR(TD(dclass="left important", content=U(cd.get('title')))))
textRows.append(
TR(
TD(dclass="left",
content='label/catalog: ' + B(cd.get('catalog')))))
if cd.get('year'):
textRows.append(
TR(TD(dclass="left", content='issued: ' + B(cd.get('year')))))
if cd.get('venue'):
textRows.append(
TR(TD(dclass="left", content='venue: ' + B(cd.get('venue')))))
if cd.get('date'):
textRows.append(
TR(
TD(dclass="left",
content='recorded live: ' +
B(textDate(cd.get('date'))))))
if cd.get('country'):
textRows.append(
TR(
TD(dclass="left",
content='country: ' + B(cd.get('country')))))
tracks = []
for element in cd:
if element.tag == 'track':
tracks.append(LI(dclass="left", content=linkTrack(element)))
elif element.tag == 'note':
textRows.append(TR(TD(dclass="left", content=element.text)))
textRows.append(TR(TD(OL("\n".join(tracks)))))
textTD = TD(TABLE("\n".join(textRows)))
bubbles.append(DIV(dclass="bubble", content=TABLE(TR(picTD + textTD))))
# figure out how many index pages we need to create
total_index_pages = len(bubbles) / per_page # first pages are maxed out
if len(bubbles) % per_page > 0:
total_index_pages += 1 # last page is partial set
# chop away at the index_rows list, moving them into the current index page
for ipage in range(total_index_pages):
my_rows = bubbles[:
per_page] # grab the rows that go into this index page
del bubbles[:per_page] # clean up as we go
index_text = templates.getImportIndex().substitute(
TITLE=DIV(dclass="heading padded10",
content="Elton John Unauthorized CDs"),
DESCR=DIV(dclass="description", content=introduction),
ALBUMS=DIV(dclass="full_width", content="\n\n".join(my_rows)),
NAVBAR=templates.getDotsDiv(ipage, total_index_pages),
)
suffix = str(ipage + 1)
if ipage == 0: suffix = ""
with open(importpath + "index" + suffix + ".html", "w") as indexfile:
indexfile.write(index_text.encode('latin-1'))
return count
def parse_other_albums():
totalAlbums = 0
loadTracks(location.dbroot + "album_tracks.xml")
albumroot = location.docroot + "albums/international/"
picroot = albumroot + "pix/"
root = ET.parse(location.dbroot + 'other_albums.xml').getroot()
# establish next/prev links
prevcountry = None
for country in root:
if country.tag == "description": continue
if country.get('private'): continue
country.set('previcon', "")
country.set('nexticon', "")
country.set('id', re.sub(' ', '_', country.get('name')).lower())
if prevcountry != None:
prevcountry.set('nexticon', linkto("right",
country)) # forward link
country.set('previcon', linkto("left",
prevcountry)) # backward link
prevcountry = country
indexrows = []
for country in root:
if country.tag == "description":
description = country.text
continue
if country.get('private'): continue
count = 0
name = country.get('name')
bubbles = []
for album in country:
print album.get('title')
if album.get('private'): continue
count += 1
totalAlbums += 1
# TBD id = album.get('id')
picfile = country.get('id') + '/' + album.get('pic')
picpath = picroot + picfile
if not os.path.isfile(picpath): print "error no pic: " + picpath
(type, width, height) = getImageInfo(picpath)
image = IMG(dclass="sleeve",
src="pix/" + picfile,
width=width,
height=height)
picTD = TD(dclass="single_sleeve", content=image)
discs = album.get('discs')
if discs: prefix = discs
else: prefix = ""
iconfile = "/pix/" + prefix + album.tag + ".gif"
iconpath = location.docroot + iconfile
(type, width, height) = getImageInfo(iconpath)
iconTD = TD(
IMG(dclass="padded10",
src=iconfile,
width=width,
height=height))
details = []
details.append(
DIV(dclass="left important", content=U(album.get('title'))))
details.append(
DIV(dclass="left", content="Year: " + B(album.get('year'))))
details.append(
DIV(dclass="left",
content="Catalog: " + B(album.get('catalog'))))
textTD = TD("\n".join(details))
headerTable = TABLE(TR(iconTD + textTD))
notes = []
tracks = []
for element in album:
if element.tag == 'tracks':
tracks = tracks + alltracks[element.get('id')]
elif element.tag == 'note':
notes.append(element.text)
elif element.tag == 'see':
notes.append(element.text)
else:
print "bad tag", element.tag
notesDiv = DIV(dclass="left padded3", content="<br/>".join(notes))
trackrows = []
for track in tracks:
tracktime = TD(dclass="time", content=track.get('length'))
tracktext = TD(dclass="track", content=linkTrack(track))
trackrows.append(TR(tracktime + tracktext))
tracksTable = TABLE("\n".join(trackrows))
detailsTD = TD(headerTable + notesDiv + tracksTable)
bubbles.append(
DIV(dclass="bubble",
content=TABLE(dclass="single_issue",
content=TR(picTD + detailsTD))))
page_template = templates.getInternationalAlbumTemplate(name)
page_text = page_template.substitute(NEXTICON=country.get('nexticon'),
PREVICON=country.get('previcon'),
COUNTRY=DIV(dclass="heading",
content="select " +
name + " pressings"),
ALBUMS="\n".join(bubbles))
target = country.get('id') + ".html"
with open(albumroot + target, "w") as countryfile:
countryfile.write(page_text.encode('UTF-8'))
flagimg = A(href=target,
content=IMG(dclass="hardleft20",
src="/pix/flags/" + country.get('id') +
".gif"))
namespan = SPAN(dclass="important hardleft200",
content=A(href=target, content=name))
s = ""
if count > 1: s = "s"
countspan = SPAN(dclass="important hardleft400",
content=A(href=target,
content=str(count) + " pressing" + s))
indexrows.append(
DIV(dclass="left bubble", content=flagimg + namespan + countspan))
index_template = templates.getInternationalIndexTemplate()
index_text = index_template.substitute(
EXTRA_STYLE="",
PAGE_TITLE="Elton John International Albums",
PAGE_CONTENT=DIV(dclass="description", content=description) +
"".join(indexrows),
)
with open(albumroot + "index.html", "w") as indexfile:
indexfile.write(index_text)
return totalAlbums
def generate_tours() :
hiddenrowID = 0
yearlist = defaultdict(list)
locationlist = defaultdict(list)
root = XML.parse(location.dbroot+"newconcerts.xml").getroot()
for concert in root:
if concert.tag == 'introduction':
introduction = concert.text
continue
if concert.get('canceled'): continue
if concert.get('postponed'): continue
if concert.get('private'): continue
ymd = concert.get('date')
(year,month,day) = ymd.split('-')
venue = concert.get('venue')
city = concert.get('city')
country = concert.get('country')
tour = concert.get('tour')
toggler = ""
if len(list(concert)) == 0: # if concert has any child elements
row1 = (TR(TD(dmy(ymd))+TD(venue)+TD(city+", "+country)+TD(tour)+TD("")))
row2 = ""
else:
hiddenrowID += 1
elemID = "elem"+str(hiddenrowID)
row1 = TR(TD(dmy(ymd))+TD(venue)+TD(city+", "+country)+TD(tour)+TD(onClick="toggle(\'"+elemID+"\')",style="cursor: pointer;",content=U("details")))
row2 = TR(TD(dclass="left indent", style="display:none;", id=elemID, colspan=5,content=getDetails(concert)))
yearlist[year].append(row1+row2)
locationlist[getLocation(city,country)].append(row1+row2)
year_opts = []
year_opts.append(OPTION(value="index.html", content="Show Elton John Concerts By Year..."))
for year in sorted(yearlist):
year_opts.append(OPTION(value=str(year)+".html",content=str(year)+" ("+str(len(yearlist[year]))+") concerts"))
yearSelector = SELECT(dclass="margin20 bold", size=1, onChange="showConcerts(this)", content="\n".join(year_opts))
loc_opts = []
loc_opts.append(OPTION(value="index.html", content="Show Elton John Concerts By Location..."))
for loc in sorted(locationlist):
loc_opts.append(OPTION(value=linkto(loc), content=loc+" ("+str(len(locationlist[loc]))+") concerts"))
locSelector = SELECT(dclass="margin20 bold", size=1, onChange="showConcerts(this)", content="\n".join(loc_opts))
headerRow = TR(dclass="bold underline large", content=TD("Date")+TD("Venue")+TD("City")+TD("Tour")+TD(""))
for year in sorted(yearlist):
print year
title = DIV(dclass="bold important padded10", content="Elton John " + year + " Concerts:")
listing = TABLE(dclass="small center full_width", content=headerRow + "".join(yearlist[year]))
tourtext = templates.getTourIndex().substitute(
PAGE_CONTENT = yearSelector + locSelector + title + listing,
)
with open(toursroot + year + ".html","w") as yearfile:
yearfile.write(tourtext.encode('UTF-8'))
for loc in sorted(locationlist):
title = DIV(dclass="bold important padded10", content="Elton John " + loc + " Concerts:")
listing = TABLE(dclass="small center full_width", content=headerRow + "".join(locationlist[loc]))
tourtext = templates.getTourIndex().substitute(
PAGE_CONTENT = yearSelector + locSelector + title + listing,
)
with open(toursroot + linkto(loc),"w") as locfile:
locfile.write(tourtext.encode('UTF-8'))
indextext = templates.getTourIndex().substitute(
PAGE_CONTENT = DIV(dclass="bubble description", content=introduction + "<br/>" + yearSelector + locSelector),
)
with open(toursroot + "index.html",'w') as indexfile:
indexfile.write(indextext)
return len(root)