forked from boyska/sito-hackit-17
144 lines
3.9 KiB
Python
144 lines
3.9 KiB
Python
'''
|
|
Manage talks scheduling in a semantic way
|
|
'''
|
|
|
|
from __future__ import print_function
|
|
import os
|
|
import io
|
|
from functools import wraps
|
|
import logging
|
|
import re
|
|
import datetime
|
|
import shutil
|
|
|
|
from docutils import nodes
|
|
from docutils.parsers.rst import directives, Directive
|
|
|
|
from pelican import signals, generators
|
|
import jinja2
|
|
|
|
|
|
TALKS_PATH = 'talks'
|
|
|
|
|
|
def memoize(function):
|
|
'''decorators to cache'''
|
|
memo = {}
|
|
|
|
@wraps(function)
|
|
def wrapper(*args):
|
|
if args in memo:
|
|
return memo[args]
|
|
else:
|
|
rv = function(*args)
|
|
memo[args] = rv
|
|
return rv
|
|
return wrapper
|
|
|
|
|
|
@memoize
|
|
def get_talk_names():
|
|
return [name for name in os.listdir(TALKS_PATH)
|
|
if not name.startswith('_') and
|
|
get_talk_data(name) is not None
|
|
]
|
|
|
|
|
|
@memoize
|
|
def get_talk_data(talkname):
|
|
fname = os.path.join(TALKS_PATH, talkname, 'meta.yaml')
|
|
if not os.path.isfile(fname):
|
|
return None
|
|
with io.open(fname, encoding='utf8') as buf:
|
|
data = yaml.load(buf)
|
|
if data is None:
|
|
return None
|
|
if 'title' not in data:
|
|
logging.warn("Talk <{}> has no `title` field".format(talkname))
|
|
data['title'] = talkname
|
|
if 'text' not in data:
|
|
logging.warn("Talk <{}> has no `text` field".format(talkname))
|
|
data['text'] = ''
|
|
if 'duration' not in data:
|
|
logging.info("Talk <{}> has no `duration` field".format(talkname))
|
|
data['duration'] = 50
|
|
data['duration'] = int(data['duration'])
|
|
if 'room' not in data:
|
|
logging.warn("Talk <{}> has no `room` field".format(talkname))
|
|
if 'time' not in data or 'day' not in data:
|
|
logging.error("Talk <{}> has no `time` or `day`".format(talkname))
|
|
if 'time' in data:
|
|
timeparts = re.findall(r'\d+', str(data['time']))
|
|
if 4 > len(timeparts) > 0:
|
|
timeparts = [int(p) for p in timeparts]
|
|
data['time'] = datetime.time(*timeparts)
|
|
else:
|
|
logging.error("Talk <{}> has malformed `time`".format(talkname))
|
|
data['id'] = talkname
|
|
resdir = os.path.join(TALKS_PATH, talkname, 'res')
|
|
if os.path.isdir(resdir) and os.listdir(resdir):
|
|
data['resources'] = resdir
|
|
return data
|
|
|
|
|
|
jinja_env = jinja2.Environment(
|
|
loader=jinja2.FileSystemLoader(os.path.join(TALKS_PATH, '_templates')),
|
|
autoescape=True,
|
|
)
|
|
|
|
|
|
class TalkListDirective(Directive):
|
|
required_arguments = 0
|
|
optional_arguments = 0
|
|
final_argument_whitespace = True
|
|
has_content = True
|
|
|
|
def run(self):
|
|
tmpl = jinja_env.get_template('talk.html')
|
|
return [
|
|
nodes.raw('', tmpl.render(**get_talk_data(n)),
|
|
format='html')
|
|
for n in get_talk_names()
|
|
]
|
|
|
|
|
|
class TalksGenerator(generators.Generator):
|
|
def __init__(self, *args, **kwargs):
|
|
self.talks = []
|
|
super(TalksGenerator, self).__init__(*args, **kwargs)
|
|
|
|
def generate_context(self):
|
|
self.talks = {n: get_talk_data(n) for n in get_talk_names()}
|
|
self._update_context(('talks',))
|
|
|
|
def generate_output(self, writer=None):
|
|
for talkname in self.talks:
|
|
if 'resources' in self.talks[talkname]:
|
|
outdir = os.path.join(self.output_path, 'talks', talkname,
|
|
'res')
|
|
if os.path.isdir(outdir):
|
|
shutil.rmtree(outdir)
|
|
shutil.copytree(self.talks[talkname]['resources'], outdir)
|
|
|
|
|
|
def add_talks_option_defaults(pelican):
|
|
pelican.settings.setdefault('TALKS_PATH', TALKS_PATH)
|
|
|
|
|
|
def get_generators(gen):
|
|
return TalksGenerator
|
|
|
|
|
|
try:
|
|
import yaml
|
|
except ImportError:
|
|
print('ERROR: yaml not found. Talks plugins will be disabled')
|
|
|
|
def register():
|
|
pass
|
|
else:
|
|
|
|
def register():
|
|
signals.get_generators.connect(get_generators)
|
|
signals.initialized.connect(add_talks_option_defaults)
|
|
directives.register_directive('talklist', TalkListDirective)
|