Tidied up generate-html.py, added more strings to be translated

This commit is contained in:
Phil Howard 2015-11-14 00:55:20 +00:00
parent 31c23e23b7
commit 5c7963b2d3
1 changed files with 313 additions and 308 deletions

View File

@ -11,12 +11,14 @@ import urlmapper
reload(sys) reload(sys)
sys.setdefaultencoding('utf8') sys.setdefaultencoding('utf8')
def cssify(value): def cssify(value):
value = slugify(value); value = slugify(value);
if value[0] == '3' or value[0] == '5': if value[0] == '3' or value[0] == '5':
value = 'pow' + value value = 'pow' + value
return value return value
def slugify(value): def slugify(value):
""" """
@ -28,158 +30,164 @@ def slugify(value):
value = re.sub('[^\w\s-]', '', value).strip().lower() value = re.sub('[^\w\s-]', '', value).strip().lower()
return re.sub('[-\s]+', '_', value) return re.sub('[-\s]+', '_', value)
def load_overlay(overlay): def load_overlay(overlay):
try: try:
data = markjaml.load('src/{}/overlay/{}.md'.format(lang,overlay)) data = markjaml.load('src/{}/overlay/{}.md'.format(lang, overlay))
loaded = data['data'] loaded = data['data']
loaded['long_description'] = data['html'] loaded['long_description'] = data['html']
except IOError: except IOError:
return None return None
details = []
details = [] if 'type' not in loaded:
loaded['type'] = 'addon'
if 'manufacturer' in loaded: if 'manufacturer' in loaded:
details.append(strings['made_by'].format(manufacturer=loaded['manufacturer'])) details.append('* ' + strings['made_by'].format(manufacturer=loaded['manufacturer']))
if 'pincount' in loaded: if 'pincount' in loaded:
pincount = int(loaded['pincount']) pincount = int(loaded['pincount'])
if pincount == 40: if pincount == 40:
details.append(strings['type_hat']) details.append('* ' + strings['type_hat'])
elif pincount == 26: elif pincount == 26:
details.append(strings['type_classic']) details.append('* ' + strings['type_classic'])
else: else:
details.append(strings['pin_header'].format(pincount)) details.append('* ' + strings['pin_header'].format(pincount))
if 'pin' in loaded: if 'pin' in loaded:
uses_5v = False uses_5v = False
uses_3v = False uses_3v = False
uses = 0 uses = 0
for pin in loaded['pin']: for pin in loaded['pin']:
pin = str(pin) pin = str(pin)
if pin.startswith('bcm'): if pin.startswith('bcm'):
pin = pinout.bcm_to_physical(pin[3:]) pin = pinout.bcm_to_physical(pin[3:])
if pin in pinout.pins: if pin in pinout.pins:
actual_pin = pinout.pins[pin] actual_pin = pinout.pins[pin]
if actual_pin['type'] in ['+3v3','+5v','GND']: if actual_pin['type'] in ['+3v3', '+5v', 'GND']:
if actual_pin['type'] == '+3v3': if actual_pin['type'] == '+3v3':
uses_3v = True uses_3v = True
if actual_pin['type'] == '+5v': if actual_pin['type'] == '+5v':
uses_5v = True uses_5v = True
else: else:
uses += 1 uses += 1
if uses > 0: if uses > 0:
details.append('* Uses {} GPIO pins'.format(uses)) details.append(strings['uses_n_gpio_pins'].format(uses))
if '3' in loaded['pin'] and '5' in loaded['pin']: if '3' in loaded['pin'] and '5' in loaded['pin']:
pin_3 = loaded['pin']['3'] pin_3 = loaded['pin']['3']
pin_5 = loaded['pin']['5'] pin_5 = loaded['pin']['5']
if 'mode' in pin_3 and 'mode' in pin_5: if 'mode' in pin_3 and 'mode' in pin_5:
if pin_3['mode'] == 'i2c' and pin_5['mode'] == 'i2c': if pin_3['mode'] == 'i2c' and pin_5['mode'] == 'i2c':
details.append(strings['uses_i2c']) details.append('* ' + strings['uses_i2c'])
if 'url' in loaded: if 'url' in loaded:
details.append('* [More Information]({url})'.format(url=loaded['url'])) details.append('* [{text}]({url})'.format(text=strings['more_information'], url=loaded['url']))
if 'github' in loaded: if 'github' in loaded:
details.append('* [GitHub Repository]({url})'.format(url=loaded['github'])) details.append('* [{text}]({url})'.format(text=strings['github_repository'], url=loaded['github']))
if 'buy' in loaded: if 'buy' in loaded:
details.append('* [Buy Now]({url})'.format(url=loaded['buy'])) details.append('* [{text}]({url})'.format(text=strings['buy_now'], url=loaded['buy']))
if loaded['type'] != 'info':
loaded['long_description'] = '{}\n{}'.format(loaded['long_description'], markdown.markdown('\n'.join(details)))
loaded['long_description'] = '{}\n{}'.format(loaded['long_description'],markdown.markdown('\n'.join(details))) if 'page_url' not in loaded:
loaded['page_url'] = slugify(loaded['name'])
if not 'page_url' in loaded: loaded['rendered_html'] = render_overlay_page(loaded)
loaded['page_url'] = slugify(loaded['name']) loaded['src'] = overlay
pages[loaded['page_url']] = loaded
navs[loaded['page_url']] = render_nav(loaded['page_url'], overlay=loaded)
select_overlays.append((loaded['page_url'], loaded['name']))
return loaded
loaded['rendered_html'] = render_overlay_page(loaded)
loaded['src'] = overlay
pages[loaded['page_url']] = loaded
navs[loaded['page_url']] = render_nav(loaded['page_url'], overlay=loaded)
select_overlays.append((loaded['page_url'], loaded['name']))
return loaded
def load_md(filename): def load_md(filename):
filename = 'src/{}/{}'.format(lang, filename) filename = 'src/{}/{}'.format(lang, filename)
try: try:
html = markdown.markdown(open(filename).read(), extensions=['fenced_code']) html = markdown.markdown(open(filename).read(), extensions=['fenced_code'])
return html
except IOError:
print('Unable to load markdown from {}'.format(filename))
return ''
return html
except IOError:
print('Unable to load markdown from {}'.format(filename))
return ''
def render_pin_text(pin_num, pin_url, pin_name, pin_functions, pin_subtext): def render_pin_text(pin_num, pin_url, pin_name, pin_functions, pin_subtext):
return '<article class="{pin_url}"><h1>{pin_name}</h1>{pin_functions}{pin_subtext}{pin_text}</article>'.format( return '<article class="{pin_url}"><h1>{pin_name}</h1>{pin_functions}{pin_subtext}{pin_text}</article>'.format(
pin_url=pin_url, pin_url=pin_url,
pin_name=pin_name, pin_name=pin_name,
pin_functions=pin_functions, pin_functions=pin_functions,
pin_subtext=pin_subtext, pin_subtext=pin_subtext,
pin_text=load_md('pin/pin-{}.md'.format(pin_num))) pin_text=load_md('pin/pin-{}.md'.format(pin_num)))
def render_overlay_page(overlay): def render_overlay_page(overlay):
if overlay == None: if overlay is None:
return '' return ''
return '<article class="page_{}">{}</article>'.format(slugify(overlay['name']),overlay['long_description']) return '<article class="page_{}">{}</article>'.format(slugify(overlay['name']), overlay['long_description'])
def render_alternate(handle, name): def render_alternate(handle, name):
handle = slugify(handle.lower()) handle = slugify(handle.lower())
return '<span class="alternate legend_{}">{}</span>'.format(handle,name) return '<span class="alternate legend_{}">{}</span>'.format(handle, name)
def render_pin_page(pin_num): def render_pin_page(pin_num):
pin = pinout.pins[str(pin_num)] pin = pinout.pins[str(pin_num)]
pin_url = pin['name'] pin_url = pin['name']
if pin_url == 'Ground': if pin_url == 'Ground':
return (None, None, None) return None, None, None
pin_text_name = pin['name'] pin_text_name = pin['name']
pin_subtext = [] pin_subtext = []
pin_subtext.append(strings['physical_pin_n'].format(pin_num))
pin_subtext.append('Physical pin {}'.format(pin_num)) if 'scheme' in pin:
if 'bcm' in pin['scheme']:
bcm = pin['scheme']['bcm']
pin_url = 'gpio{}'.format(bcm)
if 'scheme' in pin: pin_text_name = 'BCM {}'.format(bcm)
if 'bcm' in pin['scheme']:
bcm = pin['scheme']['bcm']
pin_url = 'gpio{}'.format(bcm)
pin_text_name = 'BCM {}'.format(bcm) if pin['name'] != '':
pin_subname_text = '({})'.format(pin['name'])
pin_subtext.append('BCM pin {}'.format(bcm))
if 'wiringpi' in pin['scheme']:
wiringpi = pin['scheme']['wiringpi']
pin_subtext.append('Wiring Pi pin {}'.format(wiringpi))
if 'bcmAlt' in pin['scheme']:
bcmAlt = pin['scheme']['bcmAlt']
pin_subtext.append(strings['bcm_pin_rev1_pi'].format(bcmAlt))
if pin['name'] != '': if 'description' in pin:
pin_subname_text = '({})'.format(pin['name']) pin_text_name = '{} ({})'.format(pin_text_name, pin['description'])
pin_subtext.append('BCM pin {}'.format(bcm))
if 'wiringpi' in pin['scheme']:
wiringpi = pin['scheme']['wiringpi']
pin_subtext.append('Wiring Pi pin {}'.format(wiringpi))
if 'bcmAlt' in pin['scheme']:
bcmAlt = pin['scheme']['bcmAlt']
pin_subtext.append('BCM pin {} on Rev 1 ( very early ) Pi'.format(bcmAlt))
if 'description' in pin: fn_headings = []
pin_text_name = '{} ({})'.format(pin_text_name, pin['description']) fn_functions = []
pin_functions = ''
if 'functions' in pin:
for x in range(6):
fn_headings.append('Alt' + str(x))
fn_headings = [] function = ''
fn_functions = [] if 'alt' + str(x) in pin['functions']:
pin_functions = '' function = pin['functions']['alt' + str(x)]
if 'functions' in pin:
for x in range(6):
fn_headings.append( 'Alt' + str(x) )
function = '' fn_functions.append(function)
if 'alt' + str(x) in pin['functions']:
function = pin['functions']['alt' + str(x)]
fn_functions.append( function ) pin_functions = '''<table class="pin-functions">
pin_functions = '''<table class="pin-functions">
<thead> <thead>
<tr> <tr>
<th>{headings}</th> <th>{headings}</th>
@ -192,154 +200,156 @@ def render_pin_page(pin_num):
</tbody> </tbody>
</table>'''.format(headings='</th><th>'.join(fn_headings), functions='</td><td>'.join(fn_functions)) </table>'''.format(headings='</th><th>'.join(fn_headings), functions='</td><td>'.join(fn_functions))
pin_url = slugify('pin{}_{}'.format(pin_num, pin_url))
pin_text = render_pin_text(
pin_num,
pin_url = slugify('pin{}_{}'.format(pin_num,pin_url)) pin_url,
pin_text_name,
pin_text = render_pin_text( pin_functions,
pin_num, '<ul><li>{}</li></ul>'.format('</li><li>'.join(pin_subtext))
pin_url, )
pin_text_name, # if pin_text != None:
pin_functions, return pin_url, pin_text, pin_text_name # pages[pin_url] = pin_text
'<ul><li>{}</li></ul>'.format('</li><li>'.join(pin_subtext))
)
#if pin_text != None:
return (pin_url, pin_text, pin_text_name) #pages[pin_url] = pin_text
def render_pin(pin_num, selected_url, overlay=None): def render_pin(pin_num, selected_url, overlay=None):
pin = pinout.pins[str(pin_num)] pin = pinout.pins[str(pin_num)]
pin_type = list([x.strip() for x in pin['type'].lower().split('/')])
pin_url = pin['name']
pin_name = pin['name']
pin_used = False
pin_link_title = []
bcm_pin = None
if 'scheme' in pin:
if 'bcm' in pin['scheme']:
bcm_pin = 'bcm' + str(pin['scheme']['bcm'])
pin_type = list([x.strip() for x in pin['type'].lower().split('/')]) if overlay is not None and (pin_num in overlay['pin'] or str(pin_num) in overlay['pin'] or bcm_pin in overlay['pin']):
pin_url = pin['name']
pin_name = pin['name']
pin_used = False
pin_link_title = []
bcm_pin = None
if 'scheme' in pin:
if 'bcm' in pin['scheme']:
bcm_pin = 'bcm' + str(pin['scheme']['bcm'])
if overlay != None and ( pin_num in overlay['pin'] or str(pin_num) in overlay['pin'] or bcm_pin in overlay['pin']): if pin_num in overlay['pin']:
overlay_pin = overlay['pin'][pin_num]
elif str(pin_num) in overlay['pin']:
overlay_pin = overlay['pin'][str(pin_num)]
else:
overlay_pin = overlay['pin'][bcm_pin]
if pin_num in overlay['pin']: if overlay_pin is None:
overlay_pin = overlay['pin'][pin_num] overlay_pin = {}
elif str(pin_num) in overlay['pin']:
overlay_pin = overlay['pin'][str(pin_num)]
else:
overlay_pin = overlay['pin'][bcm_pin]
if overlay_pin == None: pin_used = True
overlay_pin = {} # print(overlay)
if 'name' in overlay_pin:
pin_name = overlay_pin['name']
pin_used = True if 'description' in overlay_pin:
#print(overlay) pin_link_title.append(overlay_pin['description'])
if 'name' in overlay_pin:
pin_name = overlay_pin['name']
if 'description' in overlay_pin: if 'scheme' in pin:
pin_link_title.append(overlay_pin['description']) if 'bcm' in pin['scheme']:
bcm = pin['scheme']['bcm']
pin_subname = ''
# pin_subname_text = ''
# if pin_url == '':
pin_url = 'gpio{}'.format(bcm)
if pin_name != '': # pin['name'] != '':
pin_subname = '<small>({})</small>'.format(pin_name) # pin['name'])
pin_name = 'BCM {} {}'.format(bcm, pin_subname)
if 'wiringpi' in pin['scheme']:
wiringpi = pin['scheme']['wiringpi']
pin_link_title.append(strings['wiring_pi_pin'].format(wiringpi))
if 'scheme' in pin: pin_url = base_url + slugify('pin{}_{}'.format(pin_num, pin_url))
if 'bcm' in pin['scheme']:
bcm = pin['scheme']['bcm']
pin_subname = ''
#pin_subname_text = ''
#if pin_url == '':
pin_url = 'gpio{}'.format(bcm)
if pin_name != '': #pin['name'] != '':
pin_subname = '<small>({})</small>'.format(pin_name) #pin['name'])
pin_name = 'BCM {} {}'.format(bcm, pin_subname)
if 'wiringpi' in pin['scheme']:
wiringpi = pin['scheme']['wiringpi']
pin_link_title.append(strings['wiring_pi_pin'].format(wiringpi))
pin_url = base_url + slugify('pin{}_{}'.format(pin_num,pin_url)) if pin['type'] in pinout.get_setting('urls'):
pin_url = base_url + pinout.get_setting('urls')[pin['type']]
if pin['type'] in pinout.get_setting('urls'): selected = ''
pin_url = base_url + pinout.get_setting('urls')[pin['type']]
selected = '' if base_url + selected_url == pin_url:
selected = ' active'
if pin_used:
selected += ' overlay-pin'
if base_url + selected_url == pin_url: pin_url = pin_url + url_suffix
selected = ' active'
if pin_used:
selected += ' overlay-pin'
return '<li class="pin{pin_num} {pin_type}{pin_selected}"><a href="{pin_url}" title="{pin_title}"><span class="default"><span class="phys">{pin_num}</span> {pin_name}</span><span class="pin"></span></a></li>\n'.format(
pin_num=pin_num,
pin_type=' '.join(map(cssify, pin_type)),
pin_selected=selected,
pin_url=pin_url,
pin_title=', '.join(pin_link_title),
pin_name=pin_name,
langcode=lang
)
pin_url = pin_url + url_suffix
return '<li class="pin{pin_num} {pin_type}{pin_selected}"><a href="{pin_url}" title="{pin_title}"><span class="default"><span class="phys">{pin_num}</span> {pin_name}</span><span class="pin"></span></a></li>\n'.format(
pin_num = pin_num,
pin_type = ' '.join(map(cssify,pin_type)),
pin_selected = selected,
pin_url = pin_url,
pin_title = ', '.join(pin_link_title),
pin_name = pin_name,
langcode = lang
)
def render_nav(url, overlay=None): def render_nav(url, overlay=None):
html_odd = '' html_odd = ''
html_even = '' html_even = ''
for odd in range(1,len(pinout.pins),2): for odd in range(1, len(pinout.pins), 2):
html_odd += render_pin(odd, url,overlay) html_odd += render_pin(odd, url, overlay)
html_even += render_pin(odd+1,url,overlay) html_even += render_pin(odd + 1, url, overlay)
return '''<ul class="bottom"> return '''<ul class="bottom">
{}</ul> {}</ul>
<ul class="top"> <ul class="top">
{}</ul>'''.format(html_odd, html_even) {}</ul>'''.format(html_odd, html_even)
def get_hreflang_urls(src): def get_hreflang_urls(src):
hreflang = [] hreflang = []
for lang in sorted(alternate_urls): for lang in sorted(alternate_urls):
if src in alternate_urls[lang]: if src in alternate_urls[lang]:
url = alternate_urls[lang][src] url = alternate_urls[lang][src]
hreflang.append('<link rel="alternate" href="{url}" hreflang="{lang}"/>'.format( hreflang.append('<link rel="alternate" href="{url}" hreflang="{lang}"/>'.format(
lang=lang, lang=lang,
url=url url=url
)) ))
return hreflang return hreflang
def get_lang_urls(src): def get_lang_urls(src):
urls = [] urls = []
for url_lang in sorted(alternate_urls): for url_lang in sorted(alternate_urls):
if src in alternate_urls[url_lang]: if src in alternate_urls[url_lang]:
img_css = '' img_css = ''
if url_lang == lang: if url_lang == lang:
img_css = ' class="grayscale"' img_css = ' class="grayscale"'
url = alternate_urls[url_lang][src] url = alternate_urls[url_lang][src]
urls.append('<li><a href="{url}" rel="alternate" hreflang="{lang}"><img{css} src="{resource_url}{lang}.png" /></a>'.format( urls.append(
lang=url_lang, '<li><a href="{url}" rel="alternate" hreflang="{lang}"><img{css} src="{resource_url}{lang}.png" /></a>'.format(
url=url, lang=url_lang,
resource_url=resource_url, url=url,
css=img_css resource_url=resource_url,
)) css=img_css
return urls ))
return urls
''' '''
Main Program Flow Main Program Flow
''' '''
lang = "en" lang = "en"
default_strings = { default_strings = {
'made_by': '* Made by {manufacturer}', 'made_by': 'Made by {manufacturer}',
'type_hat': '* HAT form-factor', 'type_hat': 'HAT form-factor',
'type_classic': '* Classic form-factor', 'type_classic': 'Classic form-factor',
'pin_header': '* {} pin header', 'pin_header': '{} pin header',
'uses_i2c': '* Uses I2C', 'uses_i2c': 'Uses I2C',
'wiring_pi_pin': 'Wiring Pi pin {}' 'wiring_pi_pin': 'Wiring Pi pin {}',
'uses_n_gpio_pins': '* Uses {} GPIO pins',
'bcm_pin_rev1_pi': 'BCM pin {} on Rev 1 ( very early ) Pi',
'physical_pin_n': 'Physical pin {}',
'more_information': 'More Information',
'github_repository': 'GitHub Repository',
'buy_now': 'Buy Now'
} }
if len(sys.argv) > 1: if len(sys.argv) > 1:
lang = sys.argv[1] lang = sys.argv[1]
alternate_urls = urlmapper.generate_urls(lang) alternate_urls = urlmapper.generate_urls(lang)
@ -347,22 +357,21 @@ pinout.load(lang)
overlays = pinout.settings['overlays'] overlays = pinout.settings['overlays']
strings = pinout.get_setting('strings',{}) strings = pinout.get_setting('strings', {})
if type(strings) == list: if type(strings) == list:
_strings = {} _strings = {}
for item in strings: for item in strings:
_strings[item.keys()[0]] = item.values()[0] _strings[item.keys()[0]] = item.values()[0]
strings = _strings strings = _strings
for key, val in default_strings.items(): for key, val in default_strings.items():
if key not in strings: if key not in strings:
strings[key] = val strings[key] = val
base_url = pinout.get_setting('base_url', '/pinout/') # '/pinout-tr/pinout/'
base_url = pinout.get_setting('base_url','/pinout/') # '/pinout-tr/pinout/' resource_url = pinout.get_setting('resource_url', '/resources/') # '/pinout-tr/resources/'
resource_url = pinout.get_setting('resource_url','/resources/') # '/pinout-tr/resources/' url_suffix = pinout.get_setting('url_suffix', '') # '.html'
url_suffix = pinout.get_setting('url_suffix','') # '.html'
template = open('src/{}/template/layout.html'.format(lang)).read() template = open('src/{}/template/layout.html'.format(lang)).read()
@ -372,29 +381,26 @@ select_overlays = []
overlays_html = '' overlays_html = ''
if not os.path.isdir('output'): if not os.path.isdir('output'):
try: try:
os.mkdir('output') os.mkdir('output')
except OSError: except OSError:
exit('Failed to create output dir') exit('Failed to create output dir')
if not os.path.isdir('output/{}'.format(lang)): if not os.path.isdir('output/{}'.format(lang)):
try: try:
os.mkdir('output/{}'.format(lang)) os.mkdir('output/{}'.format(lang))
except OSError: except OSError:
exit('Failed to create output/{} dir'.format(lang)) exit('Failed to create output/{} dir'.format(lang))
if not os.path.isdir('output/{}/pinout'.format(lang)): if not os.path.isdir('output/{}/pinout'.format(lang)):
try: try:
os.mkdir('output/{}/pinout'.format(lang)) os.mkdir('output/{}/pinout'.format(lang))
except OSError: except OSError:
exit('Failed to create output/{}/pinout dir'.format(lang)) exit('Failed to create output/{}/pinout dir'.format(lang))
overlays = map(load_overlay, overlays)
overlays = map(load_overlay,overlays)
for url, name in select_overlays: for url, name in select_overlays:
overlays_html += '<li><a href="{}{}">{}</a></li>'.format(base_url, url, name) overlays_html += '<li><a href="{}{}">{}</a></li>'.format(base_url, url, name)
''' '''
Manually add the index page as 'pinout', this is due to how the Manually add the index page as 'pinout', this is due to how the
@ -404,79 +410,78 @@ and all other pages in /pinout/
serve.py will mirror this structure for testing. serve.py will mirror this structure for testing.
''' '''
pages['index'] = {} pages['index'] = {}
pages['index']['rendered_html'] = render_overlay_page({'name':'Index','long_description':load_md('index.md')}) pages['index']['rendered_html'] = render_overlay_page({'name': 'Index', 'long_description': load_md('index.md')})
navs['index'] = render_nav('pinout') navs['index'] = render_nav('pinout')
print('Rendering pin pages...') print('Rendering pin pages...')
for pin in range(1,len(pinout.pins)+1): for pin in range(1, len(pinout.pins) + 1):
(pin_url, pin_html, pin_title) = render_pin_page(pin) (pin_url, pin_html, pin_title) = render_pin_page(pin)
if pin_url == None: if pin_url is None:
continue continue
hreflang = get_hreflang_urls('pin{}'.format(pin)) hreflang = get_hreflang_urls('pin{}'.format(pin))
langlinks = get_lang_urls('pin{}'.format(pin)) langlinks = get_lang_urls('pin{}'.format(pin))
pin_nav = render_nav(pin_url) pin_nav = render_nav(pin_url)
pin_html = pinout.render_html(template, pin_html = pinout.render_html(template,
lang_links="\n\t\t".join(langlinks), lang_links="\n\t\t".join(langlinks),
hreflang = "\n\t\t".join(hreflang), hreflang="\n\t\t".join(hreflang),
nav = pin_nav, nav=pin_nav,
content = pin_html, content=pin_html,
resource_url = resource_url, resource_url=resource_url,
overlays = overlays_html, overlays=overlays_html,
description = pinout.settings['default_desc'], description=pinout.settings['default_desc'],
title = pin_title + pinout.settings['title_suffix'], title=pin_title + pinout.settings['title_suffix'],
langcode = lang langcode=lang
) )
print('Outputting page {}'.format(pin_url)) print('Outputting page {}'.format(pin_url))
with open(os.path.join('output',lang,'pinout','{}.html'.format(pin_url)),'w') as f: with open(os.path.join('output', lang, 'pinout', '{}.html'.format(pin_url)), 'w') as f:
f.write(pin_html) f.write(pin_html)
#nav = render_nav() # nav = render_nav()
print('Rendering overlay and index pages...') print('Rendering overlay and index pages...')
for url in pages: for url in pages:
content = pages[url]['rendered_html'] content = pages[url]['rendered_html']
nav = navs[url] nav = navs[url]
hreflang = [] hreflang = []
langlinks = [] langlinks = []
if url == 'index': if url == 'index':
hreflang = get_hreflang_urls('index') hreflang = get_hreflang_urls('index')
langlinks = get_lang_urls('index') langlinks = get_lang_urls('index')
if 'src' in pages[url]: if 'src' in pages[url]:
src = pages[url]['src'] src = pages[url]['src']
hreflang = get_hreflang_urls(src) hreflang = get_hreflang_urls(src)
langlinks = get_lang_urls(src) langlinks = get_lang_urls(src)
if not 'description' in pages[url]: if not 'description' in pages[url]:
pages[url]['description'] = pinout.settings['default_desc'] pages[url]['description'] = pinout.settings['default_desc']
if 'name' in pages[url]: if 'name' in pages[url]:
pages[url]['name'] = pages[url]['name'] + pinout.settings['title_suffix'] pages[url]['name'] = pages[url]['name'] + pinout.settings['title_suffix']
else: else:
pages[url]['name'] = pinout.settings['default_title'] pages[url]['name'] = pinout.settings['default_title']
html = pinout.render_html(template, html = pinout.render_html(template,
lang_links="\n\t\t".join(langlinks), lang_links="\n\t\t".join(langlinks),
hreflang = "\n\t\t".join(hreflang), hreflang="\n\t\t".join(hreflang),
nav = nav, nav=nav,
content = content, content=content,
overlays = overlays_html, overlays=overlays_html,
resource_url = resource_url, resource_url=resource_url,
description = pages[url]['description'], description=pages[url]['description'],
title = pages[url]['name'], title=pages[url]['name'],
langcode = lang langcode=lang
) )
print('Outputting page {}'.format(url)) print('Outputting page {}'.format(url))
if url != 'index':
url = os.path.join('pinout',url)
with open(os.path.join('output',lang,'{}.html'.format(url)),'w') as f: if url != 'index':
f.write(html) url = os.path.join('pinout', url)
with open(os.path.join('output', lang, '{}.html'.format(url)), 'w') as f:
f.write(html)