librarian/pyhtml.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # This file is part of Librarian, licensed under GNU Affero GPLv3 or later.
   4 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   5 #
   6 from lxml import etree
   7 from librarian import IOFile, RDFNS, DCNS, Format
   8 from xmlutils import Xmill, tag, tagged, ifoption, tag_open_close
   9 from librarian import functions
  10 import re
  11 import random
  12
  13 IMAGE_THUMB_WIDTH = 300
  14
  15 class EduModule(Xmill):
  16     def __init__(self, options=None):
  17         super(EduModule, self).__init__(options)
  18         self.activity_counter = 0
  19         self.exercise_counter = 0
  20
  21         # text filters
  22         def swap_endlines(txt):
  23             if self.options['strofa']:
  24                 txt = txt.replace("/\n", "<br/>\n")
  25             return txt
  26         self.register_text_filter(functions.substitute_entities)
  27         self.register_text_filter(swap_endlines)
  28
  29     @tagged('div', 'stanza')
  30     def handle_strofa(self, element):
  31         self.options = {'strofa': True}
  32         return "", ""
  33
  34     def handle_powiesc(self, element):
  35         return u"""
  36 <div class="module" id="book-text">
  37 <!-- <span class="teacher-toggle">
  38   <input type="checkbox" name="teacher-toggle" id="teacher-toggle"/>
  39   <label for="teacher-toggle">Pokaż treść dla nauczyciela</label>
  40  </span>-->
  41
  42 """, u"</div>"
  43
  44     handle_autor_utworu = tag("span", "author")
  45     handle_dzielo_nadrzedne = tag("span", "collection")
  46     handle_podtytul = tag("span", "subtitle")
  47     handle_naglowek_akt = handle_naglowek_czesc = handle_srodtytul = tag("h2")
  48     handle_naglowek_scena = tag('h2')
  49     handle_naglowek_osoba = handle_naglowek_podrozdzial = tag('h3')
  50     handle_akap = handle_akap_dialog = handle_akap_cd = tag('p', 'paragraph')
  51
  52     handle_wyroznienie = tag('em')
  53     handle_tytul_dziela = tag('em', 'title')
  54     handle_slowo_obce = tag('em', 'foreign')
  55
  56     def naglowek_to_anchor(self, naglowek):
  57         return re.sub(r" +", " ", naglowek.text.strip())
  58
  59     def handle_nazwa_utworu(self, element):
  60         toc = []
  61         for naglowek in element.getparent().findall('.//naglowek_rozdzial'):
  62             a = etree.Element("a")
  63             a.attrib["href"] = "#" + self.naglowek_to_anchor(naglowek)
  64             a.text = naglowek.text
  65             atxt = etree.tostring(a, encoding=unicode)
  66             toc.append("<li>%s</li>" % atxt)
  67         toc = "<ul class='toc'>%s</ul>" % "".join(toc)
  68         add_header = "Lekcja: " if self.options['wldoc'].book_info.type in ('course', 'synthetic') else ''
  69         return "<h1 class='title'><a name='top'></a>%s" % add_header, "</h1>" + toc
  70
  71     def handle_naglowek_rozdzial(self, element):
  72         return_to_top = u"<a href='#top' class='top-link'>wróć do spisu treści</a>"
  73         anchor = "".join(tag_open_close("a", name=self.naglowek_to_anchor(element)))
  74         return return_to_top + "<h2>", anchor + "</h2>"
  75
  76     def handle_uwaga(self, _e):
  77         return None
  78
  79     def handle_aktywnosc(self, element):
  80         self.activity_counter += 1
  81         self.options = {
  82             'activity': True,
  83             'activity_counter': self.activity_counter,
  84             }
  85         submill = EduModule(dict(self.options.items() + {'sub_gen': True}.items()))
  86
  87         opis = submill.generate(element.xpath('opis')[0])
  88
  89         n = element.xpath('wskazowki')
  90         if n: wskazowki = submill.generate(n[0])
  91
  92         else: wskazowki = ''
  93         n = element.xpath('pomoce')
  94
  95         if n: pomoce = submill.generate(n[0])
  96         else: pomoce = ''
  97
  98         forma = ''.join(element.xpath('forma/text()'))
  99
 100         czas = ''.join(element.xpath('czas/text()'))
 101
 102         counter = self.activity_counter
 103
 104         return u"""
 105 <div class="activity">
 106  <div class="text">
 107   <span class="act_counter">%(counter)d.</span>
 108   %(opis)s""" % locals(), \
 109 u"""%(wskazowki)s
 110  </div>
 111  <aside class="info">
 112   <section class="infobox time"><h1>Czas</h1><p>%(czas)s min</p></section>
 113   <section class="infobox kind"><h1>Metoda</h1><p>%(forma)s</p></section>
 114   %(pomoce)s
 115  </aside>
 116  <div class="clearboth"></div>
 117 </div>
 118 """ % locals()
 119
 120     handle_opis = ifoption(sub_gen=True)(tag('div', 'description'))
 121     handle_wskazowki = ifoption(sub_gen=True)(tag('div', ('hints', 'teacher')))
 122
 123     @ifoption(sub_gen=True)
 124     @tagged('section', 'infobox materials')
 125     def handle_pomoce(self, _):
 126         return """<h1>Pomoce</h1>""", ""
 127
 128     def handle_czas(self, *_):
 129         return
 130
 131     def handle_forma(self, *_):
 132         return
 133
 134     def handle_cwiczenie(self, element):
 135         exercise_handlers = {
 136             'wybor': Wybor,
 137             'uporzadkuj': Uporzadkuj,
 138             'luki': Luki,
 139             'zastap': Zastap,
 140             'przyporzadkuj': Przyporzadkuj,
 141             'prawdafalsz': PrawdaFalsz
 142             }
 143
 144         typ = element.attrib['typ']
 145         self.exercise_counter += 1
 146         self.options = {'exercise_counter': self.exercise_counter}
 147         handler = exercise_handlers[typ](self.options)
 148         return handler.generate(element)
 149
 150     # Lists
 151     def handle_lista(self, element, attrs={}):
 152         ltype = element.attrib.get('typ', 'punkt')
 153         if ltype == 'slowniczek':
 154             surl = element.attrib.get('src', None)
 155             if surl is None:
 156                 # print '** missing src on <slowniczek>, setting default'
 157                 surl = 'http://edukacjamedialna.edu.pl/slowniczek'
 158             sxml = None
 159             if surl:
 160                 sxml = etree.fromstring(self.options['provider'].by_uri(surl).get_string())
 161             self.options = {'slowniczek': True, 'slowniczek_xml': sxml }
 162             return '<div class="slowniczek">', '</div>'
 163
 164         listtag = {'num': 'ol',
 165                'punkt': 'ul',
 166                'alfa': 'ul',
 167                'czytelnia': 'ul'}[ltype]
 168
 169         classes = attrs.get('class', '')
 170         if classes: del attrs['class']
 171
 172         attrs_s = ' '.join(['%s="%s"' % kv for kv in attrs.items()])
 173         if attrs_s: attrs_s = ' ' + attrs_s
 174
 175         return '<%s class="lista %s %s"%s>' % (listtag, ltype, classes, attrs_s), '</%s>' % listtag
 176
 177     def handle_punkt(self, element):
 178         if self.options['slowniczek']:
 179             return '<dl>', '</dl>'
 180         else:
 181             return '<li>', '</li>'
 182
 183     def handle_definiendum(self, element):
 184         nxt = element.getnext()
 185         definiens_s = ''
 186
 187         if not element.text:
 188             print "!! Empty <definiendum/>"
 189             return None
 190
 191         # let's pull definiens from another document
 192         if self.options['slowniczek_xml'] is not None and (nxt is None or nxt.tag != 'definiens'):
 193             sxml = self.options['slowniczek_xml']
 194             defloc = sxml.xpath("//definiendum[text()='%s']" % element.text)
 195             if defloc:
 196                 definiens = defloc[0].getnext()
 197                 if definiens.tag == 'definiens':
 198                     subgen = EduModule(self.options)
 199                     definiens_s = subgen.generate(definiens)
 200             else:
 201                 print '!! Missing definiendum in source:', element.text
 202
 203         return u"<dt>", u"</dt>" + definiens_s
 204
 205     def handle_definiens(self, element):
 206         return u"<dd>", u"</dd>"
 207
 208     def handle_podpis(self, element):
 209         return u"""<div class="caption">""", u"</div>"
 210
 211     def handle_tabela(self, element):
 212         has_frames = int(element.attrib.get("ramki", "0"))
 213         if has_frames: frames_c = "framed"
 214         else: frames_c = ""
 215         return u"""<table class="%s">""" % frames_c, u"</table>"
 216
 217     def handle_wiersz(self, element):
 218         return u"<tr>", u"</tr>"
 219
 220     def handle_kol(self, element):
 221         return u"<td>", u"</td>"
 222
 223     def handle_rdf__RDF(self, _):
 224         # ustal w opcjach  rzeczy :D
 225         return
 226
 227     def handle_link(self, element):
 228         if 'url' in element.attrib:
 229             return tag('a', href=element.attrib['url'])(self, element)
 230         elif 'material' in element.attrib:
 231             material_err = u' [BRAKUJĄCY MATERIAŁ]'
 232             slug = element.attrib['material']
 233             make_url = lambda f: self.options['urlmapper'] \
 234               .url_for_material(slug, f)
 235
 236             if 'format' in element.attrib:
 237                 formats = re.split(r"[, ]+",
 238                                element.attrib['format'])
 239             else:
 240                 formats = [None]
 241
 242             formats = self.options['urlmapper'].materials(slug)
 243
 244             try:
 245                 def_href = make_url(formats[0][0])
 246                 def_err = u""
 247             except (IndexError, self.options['urlmapper'].MaterialNotFound):
 248                 def_err = material_err
 249                 def_href = u""
 250             fmt_links = []
 251             for f in formats[1:]:
 252                 try:
 253                     fmt_links.append(u'<a href="%s">%s</a>' % (make_url(f[0]), f[0].upper()))
 254                 except self.options['urlmapper'].MaterialNotFound:
 255                     fmt_links.append(u'<a>%s%s</a>' % (f[0].upper(), material_err))
 256             more_links = u' (%s)' % u', '.join(fmt_links) if fmt_links else u''
 257
 258             return u"<a href='%s'>" % def_href, u'%s</a>%s' % (def_err, more_links)
 259
 260     def handle_obraz(self, element):
 261         name = element.attrib.get('nazwa', '').strip()
 262         if not name:
 263             print '!! <obraz> missing "nazwa"'
 264             return
 265         alt = element.attrib.get('alt', '')
 266         if not alt:
 267             print '** <obraz> missing "alt"'
 268         slug, ext = name.rsplit('.', 1)
 269         url = self.options['urlmapper'].url_for_image(slug, ext)
 270         thumb_url = self.options['urlmapper'].url_for_image(slug, ext, IMAGE_THUMB_WIDTH)
 271         e = etree.Element("a", attrib={"href": url, "class": "image"})
 272         e.append(etree.Element("img", attrib={"src": thumb_url, "alt": alt,
 273                     "width": str(IMAGE_THUMB_WIDTH)}))
 274         return etree.tostring(e, encoding=unicode), u""
 275
 276     def handle_video(self, element):
 277         url = element.attrib.get('url')
 278         if not url:
 279             print '!! <video> missing url'
 280             return
 281         m = re.match(r'(?:https?://)?(?:www.)?youtube.com/watch\?(?:.*&)?v=([^&]+)(?:$|&)', url)
 282         if not m:
 283             print '!! unknown <video> url scheme:', url
 284             return
 285         return """<iframe width="630" height="384" src="http://www.youtube.com/embed/%s"
 286             frameborder="0" allowfullscreen></iframe>""" % m.group(1), ""
 287
 288
 289 class Exercise(EduModule):
 290     INSTRUCTION = ""
 291     def __init__(self, *args, **kw):
 292         self.question_counter = 0
 293         super(Exercise, self).__init__(*args, **kw)
 294         self.instruction_printed = False
 295
 296     @tagged('div', 'description')
 297     def handle_opis(self, element):
 298         return "", self.get_instruction()
 299
 300     def handle_rozw_kom(self, element):
 301         return u"""<div style="display:none" class="comment">""", u"""</div>"""
 302
 303     def handle_cwiczenie(self, element):
 304         self.options = {'exercise': element.attrib['typ']}
 305         self.question_counter = 0
 306         self.piece_counter = 0
 307
 308         pre = u"""
 309 <div class="exercise %(typ)s" data-type="%(typ)s">
 310 <form action="#" method="POST">
 311 <h3>Zadanie %(exercies_counter)d</h3>
 312 <div class="buttons">
 313 <span class="message"></span>
 314 <input type="button" class="check" value="sprawdź"/>
 315 <input type="button" class="retry" style="display:none" value="spróbuj ponownie"/>
 316 <input type="button" class="solutions" value="pokaż rozwiązanie"/>
 317 <input type="button" class="reset" value="reset"/>
 318 </div>
 319
 320 """ % {'exercies_counter': self.options['exercise_counter'], 'typ': element.attrib['typ']}
 321         post = u"""
 322 <div class="buttons">
 323 <span class="message"></span>
 324 <input type="button" class="check" value="sprawdź"/>
 325 <input type="button" class="retry" style="display:none" value="spróbuj ponownie"/>
 326 <input type="button" class="solutions" value="pokaż rozwiązanie"/>
 327 <input type="button" class="reset" value="reset"/>
 328 </div>
 329 </form>
 330 </div>
 331 """
 332         # Add a single <pytanie> tag if it's not there
 333         if not element.xpath(".//pytanie"):
 334             qpre, qpost = self.handle_pytanie(element)
 335             pre = pre + qpre
 336             post = qpost + post
 337         return pre, post
 338
 339     def handle_pytanie(self, element):
 340         """This will handle <cwiczenie> element, when there is no <pytanie>
 341         """
 342         add_class = ""
 343         self.question_counter += 1
 344         self.piece_counter = 0
 345         solution = element.attrib.get('rozw', None)
 346         if solution: solution_s = ' data-solution="%s"' % solution
 347         else: solution_s = ''
 348
 349         handles = element.attrib.get('uchwyty', None)
 350         if handles:
 351             add_class += ' handles handles-%s' % handles
 352             self.options = {'handles': handles}
 353
 354         minimum = element.attrib.get('min', None)
 355         if minimum: minimum_s = ' data-minimum="%d"' % int(minimum)
 356         else: minimum_s = ''
 357
 358         return '<div class="question%s" data-no="%d" %s>' %\
 359             (add_class, self.question_counter, solution_s + minimum_s), \
 360             "</div>"
 361
 362     def get_instruction(self):
 363         if not self.instruction_printed:
 364             self.instruction_printed = True
 365             if self.INSTRUCTION:
 366                 return u'<span class="instruction">%s</span>' % self.INSTRUCTION
 367             else:
 368                 return ""
 369         else:
 370             return ""
 371
 372
 373
 374 class Wybor(Exercise):
 375     def handle_cwiczenie(self, element):
 376         pre, post = super(Wybor, self).handle_cwiczenie(element)
 377         is_single_choice = True
 378         pytania = element.xpath(".//pytanie")
 379         if not pytania:
 380             pytania = [element]
 381         for p in pytania:
 382             solutions = re.split(r"[, ]+", p.attrib['rozw'])
 383             if len(solutions) != 1:
 384                 is_single_choice = False
 385                 break
 386             choices = p.xpath(".//*[@nazwa]")
 387             uniq = set()
 388             for n in choices: uniq.add(n.attrib['nazwa'])
 389             if len(choices) != len(uniq):
 390                 is_single_choice = False
 391                 break
 392
 393         self.options = {'single': is_single_choice}
 394         return pre, post
 395
 396     def handle_punkt(self, element):
 397         if self.options['exercise'] and element.attrib.get('nazwa', None):
 398             qc = self.question_counter
 399             self.piece_counter += 1
 400             no = self.piece_counter
 401             eid = "q%(qc)d_%(no)d" % locals()
 402             aname = element.attrib.get('nazwa', None)
 403             if self.options['single']:
 404                 return u"""
 405 <li class="question-piece" data-qc="%(qc)d" data-no="%(no)d" data-name="%(aname)s">
 406 <input type="radio" name="q%(qc)d" id="%(eid)s" value="%(aname)s" />
 407 <label for="%(eid)s">
 408                 """ % locals(), u"</label></li>"
 409             else:
 410                 return u"""
 411 <li class="question-piece" data-qc="%(qc)d" data-no="%(no)d" data-name="%(aname)s">
 412 <input type="checkbox" name="%(eid)s" id="%(eid)s" />
 413 <label for="%(eid)s">
 414 """ % locals(), u"</label></li>"
 415
 416         else:
 417             return super(Wybor, self).handle_punkt(element)
 418
 419
 420 class Uporzadkuj(Exercise):
 421     INSTRUCTION = u"Kliknij wybraną odpowiedź i przeciągnij w nowe miejsce."
 422
 423     def handle_pytanie(self, element):
 424         """
 425 Overrides the returned content default handle_pytanie
 426         """
 427         # we ignore the result, returning our own
 428         super(Uporzadkuj, self).handle_pytanie(element)
 429         order_items = element.xpath(".//punkt/@rozw")
 430
 431         return u"""<div class="question" data-original="%s" data-no="%s">""" % \
 432             (','.join(order_items), self.question_counter), \
 433             u"""</div>"""
 434
 435     def handle_punkt(self, element):
 436         return """<li class="question-piece" data-pos="%(rozw)s"/>""" \
 437             % element.attrib,\
 438             "</li>"
 439
 440
 441 class Luki(Exercise):
 442     INSTRUCTION = u"Przeciągnij odpowiedzi i upuść w wybranym polu."
 443     def find_pieces(self, question):
 444         return question.xpath(".//luka")
 445
 446     def solution_html(self, piece):
 447         sub = EduModule()
 448         return sub.generate(piece)
 449         # print piece.text
 450         # return piece.text + ''.join(
 451         #     [etree.tostring(n, encoding=unicode)
 452         #      for n in piece])
 453
 454     def handle_pytanie(self, element):
 455         qpre, qpost = super(Luki, self).handle_pytanie(element)
 456
 457         luki = list(enumerate(self.find_pieces(element)))
 458         luki_html = ""
 459         i = 0
 460         random.shuffle(luki)
 461         for (i, luka) in luki:
 462             i += 1
 463             luka_html = self.solution_html(luka)
 464             luki_html += u'<span class="draggable question-piece" data-no="%d">%s</span>' % (i, luka_html)
 465         self.words_html = '<div class="words">%s</div>' % luki_html
 466
 467         return qpre, qpost
 468
 469     def handle_opis(self, element):
 470         return '', self.words_html
 471
 472     def handle_luka(self, element):
 473         self.piece_counter += 1
 474         return '<span class="placeholder" data-solution="%d"></span>' % self.piece_counter
 475
 476
 477 class Zastap(Luki):
 478     INSTRUCTION = u"Przeciągnij odpowiedzi i upuść je na słowie lub wyrażeniu, które chcesz zastąpić."
 479
 480     def find_pieces(self, question):
 481         return question.xpath(".//zastap")
 482
 483     def solution_html(self, piece):
 484         return piece.attrib['rozw']
 485
 486     def handle_zastap(self, element):
 487         self.piece_counter += 1
 488         return '<span class="placeholder zastap question-piece" data-solution="%d">' \
 489             % self.piece_counter, '</span>'
 490
 491
 492 class Przyporzadkuj(Exercise):
 493     INSTRUCTION = [u"Przeciągnij odpowiedzi i upuść w wybranym polu.",
 494                    u"Kliknij numer odpowiedzi, przeciągnij i upuść w wybranym polu."]
 495
 496     def get_instruction(self):
 497         if not self.instruction_printed:
 498             self.instruction_printed = True
 499             return u'<span class="instruction">%s</span>' % self.INSTRUCTION[self.options['handles'] and 1 or 0]
 500         else:
 501             return ""
 502
 503     def handle_cwiczenie(self, element):
 504         pre, post = super(Przyporzadkuj, self).handle_cwiczenie(element)
 505         lista_with_handles = element.xpath(".//*[@uchwyty]")
 506         if lista_with_handles:
 507             self.options = {'handles': True}
 508         return pre, post
 509
 510     def handle_pytanie(self, element):
 511         pre, post = super(Przyporzadkuj, self).handle_pytanie(element)
 512         minimum = element.attrib.get("min", None)
 513         if minimum:
 514             self.options = {"min": int(minimum)}
 515         return pre, post
 516
 517     def handle_lista(self, lista):
 518         if 'nazwa' in lista.attrib:
 519             attrs = {
 520                 'data-name': lista.attrib['nazwa'],
 521                 'class': 'predicate'
 522             }
 523             self.options = {'predicate': True}
 524         elif 'cel' in lista.attrib:
 525             attrs = {
 526                 'data-target': lista.attrib['cel'],
 527                 'class': 'subject'
 528             }
 529             self.options = {'subject': True}
 530         else:
 531             attrs = {}
 532         pre, post = super(Przyporzadkuj, self).handle_lista(lista, attrs)
 533         return pre, post + '<br class="clr"/>'
 534
 535     def handle_punkt(self, element):
 536         if self.options['subject']:
 537             self.piece_counter += 1
 538             if self.options['handles']:
 539                 return '<li><span data-solution="%s" data-no="%s" class="question-piece draggable handle add-li">%s</span>' % (element.attrib['rozw'], self.piece_counter, self.piece_counter), '</li>'
 540             else:
 541                 return '<li data-solution="%s" data-no="%s" class="question-piece draggable">' % (element.attrib['rozw'], self.piece_counter), '</li>'
 542
 543         elif self.options['predicate']:
 544             if self.options['min']:
 545                 placeholders = u'<li class="placeholder"/>' * self.options['min']
 546             else:
 547                 placeholders = u'<li class="placeholder multiple"/>'
 548             return '<li data-predicate="%(nazwa)s">' % element.attrib, '<ul class="subjects">' + placeholders + '</ul></li>'
 549
 550         else:
 551             return super(Przyporzadkuj, self).handle_punkt(element)
 552
 553
 554 class PrawdaFalsz(Exercise):
 555     def handle_punkt(self, element):
 556         if 'rozw' in element.attrib:
 557             return u'''<li data-solution="%s" class="question-piece">
 558             <span class="buttons">
 559             <a href="#" data-value="true" class="true">Prawda</a>
 560             <a href="#" data-value="false" class="false">Fałsz</a>
 561         </span>''' % {'prawda': 'true', 'falsz': 'false'}[element.attrib['rozw']], '</li>'
 562         else:
 563             return super(PrawdaFalsz, self).handle_punkt(element)
 564
 565
 566 class EduModuleFormat(Format):
 567     PRIMARY_MATERIAL_FORMATS = ('pdf', 'odt')
 568
 569     class MaterialNotFound(BaseException):
 570         pass
 571
 572     def __init__(self, wldoc, **kwargs):
 573         super(EduModuleFormat, self).__init__(wldoc, **kwargs)
 574
 575     def build(self):
 576         # Sort materials by slug.
 577         self.materials_by_slug = {}
 578         for name, att in self.wldoc.source.attachments.items():
 579             parts = name.rsplit('.', 1)
 580             if len(parts) == 1:
 581                 continue
 582             slug, ext = parts
 583             if slug not in self.materials_by_slug:
 584                 self.materials_by_slug[slug] = {}
 585             self.materials_by_slug[slug][ext] = att
 586
 587         edumod = EduModule({'provider': self.wldoc.provider, 'urlmapper': self, 'wldoc': self.wldoc})
 588
 589         html = edumod.generate(self.wldoc.edoc.getroot())
 590
 591         return IOFile.from_string(html.encode('utf-8'))
 592
 593     def materials(self, slug):
 594         """Returns a list of pairs: (ext, iofile)."""
 595         order = dict(reversed(k) for k in enumerate(self.PRIMARY_MATERIAL_FORMATS))
 596         mats = self.materials_by_slug.get(slug, {}).items()
 597         if not mats:
 598             print "!! Material missing: '%s'" % slug
 599         return sorted(mats, key=lambda (x, y): order.get(x, x))
 600
 601     def url_for_material(self, slug, fmt):
 602         return "%s.%s" % (slug, fmt)
 603
 604     def url_for_image(self, slug, fmt, width=None):
 605         return self.url_for_material(self, slug, fmt)
 606
 607
 608 def transform(wldoc, stylesheet='edumed', options=None, flags=None):
 609     """Transforms the WL document to XHTML.
 610
 611     If output_filename is None, returns an XML,
 612     otherwise returns True if file has been written,False if it hasn't.
 613     File won't be written if it has no content.
 614     """
 615     edumodfor = EduModuleFormat(wldoc)
 616     return edumodfor.build()