librarian/epub.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 __future__ import with_statement
   7
   8 import os
   9 import os.path
  10 import re
  11 import subprocess
  12 from StringIO import StringIO
  13 from copy import deepcopy
  14 from lxml import etree
  15 import zipfile
  16 from tempfile import mkdtemp, NamedTemporaryFile
  17 from shutil import rmtree
  18
  19 from librarian import RDFNS, WLNS, NCXNS, OPFNS, XHTMLNS, OutputFile
  20 from librarian.cover import DefaultEbookCover
  21
  22 from librarian import functions, get_resource
  23
  24 from librarian.hyphenator import Hyphenator
  25
  26 functions.reg_person_name()
  27 functions.reg_lang_code_3to2()
  28
  29 hyph = Hyphenator(get_resource('res/hyph-dictionaries/hyph_pl_PL.dic'))
  30
  31 def hyphenate_and_fix_conjunctions(source_tree):
  32     """ hyphenate only powiesc, opowiadanie and wywiad tag"""
  33     texts = etree.XPath('//*[self::powiesc|self::opowiadanie|self::wywiad]//text()')(source_tree)
  34     for t in texts:
  35         parent = t.getparent()
  36         newt = ''
  37         wlist = re.compile(r'\w+|[^\w]', re.UNICODE).findall(t)
  38         for w in wlist:
  39             newt += hyph.inserted(w, u'\u00AD')
  40         newt = re.sub(r'(?<=\s\w)\s+', u'\u00A0', newt)
  41         if t.is_text:
  42             parent.text = newt
  43         elif t.is_tail:
  44             parent.tail = newt
  45
  46 def inner_xml(node):
  47     """ returns node's text and children as a string
  48
  49     >>> print inner_xml(etree.fromstring('<a>x<b>y</b>z</a>'))
  50     x<b>y</b>z
  51     """
  52
  53     nt = node.text if node.text is not None else ''
  54     return ''.join([nt] + [etree.tostring(child) for child in node])
  55
  56 def set_inner_xml(node, text):
  57     """ sets node's text and children from a string
  58
  59     >>> e = etree.fromstring('<a>b<b>x</b>x</a>')
  60     >>> set_inner_xml(e, 'x<b>y</b>z')
  61     >>> print etree.tostring(e)
  62     <a>x<b>y</b>z</a>
  63     """
  64
  65     p = etree.fromstring('<x>%s</x>' % text)
  66     node.text = p.text
  67     node[:] = p[:]
  68
  69
  70 def node_name(node):
  71     """ Find out a node's name
  72
  73     >>> print node_name(etree.fromstring('<a>X<b>Y</b>Z</a>'))
  74     XYZ
  75     """
  76
  77     tempnode = deepcopy(node)
  78
  79     for p in ('pe', 'pa', 'pt', 'pr', 'motyw'):
  80         for e in tempnode.findall('.//%s' % p):
  81             t = e.tail
  82             e.clear()
  83             e.tail = t
  84     etree.strip_tags(tempnode, '*')
  85     return tempnode.text
  86
  87
  88 def xslt(xml, sheet):
  89     if isinstance(xml, etree._Element):
  90         xml = etree.ElementTree(xml)
  91     with open(sheet) as xsltf:
  92         return xml.xslt(etree.parse(xsltf))
  93
  94
  95 def replace_characters(node):
  96     def replace_chars(text):
  97         if text is None:
  98             return None
  99         return text.replace(u"\ufeff", u"")\
 100                    .replace("---", u"\u2014")\
 101                    .replace("--", u"\u2013")\
 102                    .replace(",,", u"\u201E")\
 103                    .replace('"', u"\u201D")\
 104                    .replace("'", u"\u2019")
 105     if node.tag in ('uwaga', 'extra'):
 106         t = node.tail
 107         node.clear()
 108         node.tail = t
 109     node.text = replace_chars(node.text)
 110     node.tail = replace_chars(node.tail)
 111     for child in node:
 112         replace_characters(child)
 113
 114
 115 def find_annotations(annotations, source, part_no):
 116     for child in source:
 117         if child.tag in ('pe', 'pa', 'pt', 'pr'):
 118             annotation = deepcopy(child)
 119             number = str(len(annotations)+1)
 120             annotation.set('number', number)
 121             annotation.set('part', str(part_no))
 122             annotation.tail = ''
 123             annotations.append(annotation)
 124             tail = child.tail
 125             child.clear()
 126             child.tail = tail
 127             child.text = number
 128         if child.tag not in ('extra', 'uwaga'):
 129             find_annotations(annotations, child, part_no)
 130
 131
 132 class Stanza(object):
 133     """
 134     Converts / verse endings into verse elements in a stanza.
 135
 136     Slashes may only occur directly in the stanza. Any slashes in subelements
 137     will be ignored, and the subelements will be put inside verse elements.
 138
 139     >>> s = etree.fromstring("<strofa>a <b>c</b> <b>c</b>/\\nb<x>x/\\ny</x>c/ \\nd</strofa>")
 140     >>> Stanza(s).versify()
 141     >>> print etree.tostring(s)
 142     <strofa><wers_normalny>a <b>c</b> <b>c</b></wers_normalny><wers_normalny>b<x>x/
 143     y</x>c</wers_normalny><wers_normalny>d</wers_normalny></strofa>
 144
 145     """
 146     def __init__(self, stanza_elem):
 147         self.stanza = stanza_elem
 148         self.verses = []
 149         self.open_verse = None
 150
 151     def versify(self):
 152         self.push_text(self.stanza.text)
 153         for elem in self.stanza:
 154             self.push_elem(elem)
 155             self.push_text(elem.tail)
 156         tail = self.stanza.tail
 157         self.stanza.clear()
 158         self.stanza.tail = tail
 159         self.stanza.extend(self.verses)
 160
 161     def open_normal_verse(self):
 162         self.open_verse = self.stanza.makeelement("wers_normalny")
 163         self.verses.append(self.open_verse)
 164
 165     def get_open_verse(self):
 166         if self.open_verse is None:
 167             self.open_normal_verse()
 168         return self.open_verse
 169
 170     def push_text(self, text):
 171         if not text:
 172             return
 173         for i, verse_text in enumerate(re.split(r"/\s*\n", text)):
 174             if i:
 175                 self.open_normal_verse()
 176             verse = self.get_open_verse()
 177             if len(verse):
 178                 verse[-1].tail = (verse[-1].tail or "") + verse_text
 179             else:
 180                 verse.text = (verse.text or "") + verse_text
 181
 182     def push_elem(self, elem):
 183         if elem.tag.startswith("wers"):
 184             verse = deepcopy(elem)
 185             verse.tail = None
 186             self.verses.append(verse)
 187             self.open_verse = verse
 188         else:
 189             appended = deepcopy(elem)
 190             appended.tail = None
 191             self.get_open_verse().append(appended)
 192
 193
 194 def replace_by_verse(tree):
 195     """ Find stanzas and create new verses in place of a '/' character """
 196
 197     stanzas = tree.findall('.//' + WLNS('strofa'))
 198     for stanza in stanzas:
 199         Stanza(stanza).versify()
 200
 201
 202 def add_to_manifest(manifest, partno):
 203     """ Adds a node to the manifest section in content.opf file """
 204
 205     partstr = 'part%d' % partno
 206     e = manifest.makeelement(OPFNS('item'), attrib={
 207                                  'id': partstr,
 208                                  'href': partstr + '.html',
 209                                  'media-type': 'application/xhtml+xml',
 210                              })
 211     manifest.append(e)
 212
 213
 214 def add_to_spine(spine, partno):
 215     """ Adds a node to the spine section in content.opf file """
 216
 217     e = spine.makeelement(OPFNS('itemref'), attrib={'idref': 'part%d' % partno});
 218     spine.append(e)
 219
 220
 221 class TOC(object):
 222     def __init__(self, name=None, part_href=None):
 223         self.children = []
 224         self.name = name
 225         self.part_href = part_href
 226         self.sub_number = None
 227
 228     def add(self, name, part_href, level=0, is_part=True, index=None):
 229         assert level == 0 or index is None
 230         if level > 0 and self.children:
 231             return self.children[-1].add(name, part_href, level-1, is_part)
 232         else:
 233             t = TOC(name)
 234             t.part_href = part_href
 235             if index is not None:
 236                 self.children.insert(index, t)
 237             else:
 238                 self.children.append(t)
 239             if not is_part:
 240                 t.sub_number = len(self.children) + 1
 241                 return t.sub_number
 242
 243     def append(self, toc):
 244         self.children.append(toc)
 245
 246     def extend(self, toc):
 247         self.children.extend(toc.children)
 248
 249     def depth(self):
 250         if self.children:
 251             return max((c.depth() for c in self.children)) + 1
 252         else:
 253             return 0
 254
 255     def href(self):
 256         src = self.part_href
 257         if self.sub_number is not None:
 258             src += '#sub%d' % self.sub_number
 259         return src
 260
 261     def write_to_xml(self, nav_map, counter=1):
 262         for child in self.children:
 263             nav_point = nav_map.makeelement(NCXNS('navPoint'))
 264             nav_point.set('id', 'NavPoint-%d' % counter)
 265             nav_point.set('playOrder', str(counter))
 266
 267             nav_label = nav_map.makeelement(NCXNS('navLabel'))
 268             text = nav_map.makeelement(NCXNS('text'))
 269             text.text = re.sub(r'\n', ' ', child.name)
 270             nav_label.append(text)
 271             nav_point.append(nav_label)
 272
 273             content = nav_map.makeelement(NCXNS('content'))
 274             content.set('src', child.href())
 275             nav_point.append(content)
 276             nav_map.append(nav_point)
 277             counter = child.write_to_xml(nav_point, counter + 1)
 278         return counter
 279
 280     def html_part(self, depth=0):
 281         texts = []
 282         for child in self.children:
 283             texts.append(
 284                 "<div style='margin-left:%dem;'><a href='%s'>%s</a></div>" %
 285                 (depth, child.href(), child.name))
 286             texts.append(child.html_part(depth+1))
 287         return "\n".join(texts)
 288
 289     def html(self):
 290         with open(get_resource('epub/toc.html')) as f:
 291             t = unicode(f.read(), 'utf-8')
 292         return t % self.html_part()
 293
 294
 295 def used_chars(element):
 296     """ Lists characters used in an ETree Element """
 297     chars = set((element.text or '') + (element.tail or ''))
 298     for child in element:
 299         chars = chars.union(used_chars(child))
 300     return chars
 301
 302
 303 def chop(main_text):
 304     """ divide main content of the XML file into chunks """
 305
 306     # prepare a container for each chunk
 307     part_xml = etree.Element('utwor')
 308     etree.SubElement(part_xml, 'master')
 309     main_xml_part = part_xml[0] # master
 310
 311     last_node_part = False
 312
 313     # the below loop are workaround for a problem with epubs in drama ebooks without acts
 314     is_scene = False
 315     is_act = False
 316     for one_part in main_text:
 317         name = one_part.tag
 318         if name == 'naglowek_scena':
 319             is_scene = True
 320         elif name == 'naglowek_akt':
 321             is_act = True
 322
 323     for one_part in main_text:
 324         name = one_part.tag
 325         if is_act is False and is_scene is True:
 326             if name == 'naglowek_czesc':
 327                 yield part_xml
 328                 last_node_part = True
 329                 main_xml_part[:] = [deepcopy(one_part)]
 330             elif not last_node_part and name == "naglowek_scena":
 331                 yield part_xml
 332                 main_xml_part[:] = [deepcopy(one_part)]
 333             else:
 334                 main_xml_part.append(deepcopy(one_part))
 335                 last_node_part = False
 336         else:
 337             if name == 'naglowek_czesc':
 338                 yield part_xml
 339                 last_node_part = True
 340                 main_xml_part[:] = [deepcopy(one_part)]
 341             elif not last_node_part and name in ("naglowek_rozdzial", "naglowek_akt", "srodtytul"):
 342                 yield part_xml
 343                 main_xml_part[:] = [deepcopy(one_part)]
 344             else:
 345                 main_xml_part.append(deepcopy(one_part))
 346                 last_node_part = False
 347     yield part_xml
 348
 349
 350 def transform_chunk(chunk_xml, chunk_no, annotations, empty=False, _empty_html_static=[]):
 351     """ transforms one chunk, returns a HTML string, a TOC object and a set of used characters """
 352
 353     toc = TOC()
 354     for element in chunk_xml[0]:
 355         if element.tag == "naglowek_czesc":
 356             toc.add(node_name(element), "part%d.html#book-text" % chunk_no)
 357         elif element.tag in ("naglowek_rozdzial", "naglowek_akt", "srodtytul"):
 358             toc.add(node_name(element), "part%d.html" % chunk_no)
 359         elif element.tag in ('naglowek_podrozdzial', 'naglowek_scena'):
 360             subnumber = toc.add(node_name(element), "part%d.html" % chunk_no, level=1, is_part=False)
 361             element.set('sub', str(subnumber))
 362     if empty:
 363         if not _empty_html_static:
 364             _empty_html_static.append(open(get_resource('epub/emptyChunk.html')).read())
 365         chars = set()
 366         output_html = _empty_html_static[0]
 367     else:
 368         find_annotations(annotations, chunk_xml, chunk_no)
 369         replace_by_verse(chunk_xml)
 370         html_tree = xslt(chunk_xml, get_resource('epub/xsltScheme.xsl'))
 371         chars = used_chars(html_tree.getroot())
 372         output_html = etree.tostring(html_tree, method="html", pretty_print=True)
 373     return output_html, toc, chars
 374
 375
 376 def transform(wldoc, verbose=False,
 377               style=None, html_toc=False,
 378               sample=None, cover=None, flags=None):
 379     """ produces a EPUB file
 380
 381     sample=n: generate sample e-book (with at least n paragraphs)
 382     cover: a cover.Cover factory or True for default
 383     flags: less-advertising, without-fonts, working-copy, with-full-fonts
 384     """
 385
 386     def transform_file(wldoc, chunk_counter=1, first=True, sample=None):
 387         """ processes one input file and proceeds to its children """
 388
 389         replace_characters(wldoc.edoc.getroot())
 390         hyphenate_and_fix_conjunctions(wldoc.edoc.getroot())
 391
 392         # every input file will have a TOC entry,
 393         # pointing to starting chunk
 394         toc = TOC(wldoc.book_info.title, "part%d.html" % chunk_counter)
 395         chars = set()
 396         if first:
 397             # write book title page
 398             html_tree = xslt(wldoc.edoc, get_resource('epub/xsltTitle.xsl'))
 399             chars = used_chars(html_tree.getroot())
 400             zip.writestr('OPS/title.html',
 401                  etree.tostring(html_tree, method="html", pretty_print=True))
 402             # add a title page TOC entry
 403             toc.add(u"Strona tytułowa", "title.html")
 404         elif wldoc.book_info.parts:
 405             # write title page for every parent
 406             if sample is not None and sample <= 0:
 407                 chars = set()
 408                 html_string = open(get_resource('epub/emptyChunk.html')).read()
 409             else:
 410                 html_tree = xslt(wldoc.edoc, get_resource('epub/xsltChunkTitle.xsl'))
 411                 chars = used_chars(html_tree.getroot())
 412                 html_string = etree.tostring(html_tree, method="html", pretty_print=True)
 413             zip.writestr('OPS/part%d.html' % chunk_counter, html_string)
 414             add_to_manifest(manifest, chunk_counter)
 415             add_to_spine(spine, chunk_counter)
 416             chunk_counter += 1
 417
 418         if len(wldoc.edoc.getroot()) > 1:
 419             # rdf before style master
 420             main_text = wldoc.edoc.getroot()[1]
 421         else:
 422             # rdf in style master
 423             main_text = wldoc.edoc.getroot()[0]
 424             if main_text.tag == RDFNS('RDF'):
 425                 main_text = None
 426
 427         if main_text is not None:
 428             for chunk_xml in chop(main_text):
 429                 empty = False
 430                 if sample is not None:
 431                     if sample <= 0:
 432                         empty = True
 433                     else:
 434                         sample -= len(chunk_xml.xpath('//strofa|//akap|//akap_cd|//akap_dialog'))
 435                 chunk_html, chunk_toc, chunk_chars = transform_chunk(chunk_xml, chunk_counter, annotations, empty)
 436
 437                 toc.extend(chunk_toc)
 438                 chars = chars.union(chunk_chars)
 439                 zip.writestr('OPS/part%d.html' % chunk_counter, chunk_html)
 440                 add_to_manifest(manifest, chunk_counter)
 441                 add_to_spine(spine, chunk_counter)
 442                 chunk_counter += 1
 443
 444         for child in wldoc.parts():
 445             child_toc, chunk_counter, chunk_chars, sample = transform_file(
 446                 child, chunk_counter, first=False, sample=sample)
 447             toc.append(child_toc)
 448             chars = chars.union(chunk_chars)
 449
 450         return toc, chunk_counter, chars, sample
 451
 452
 453     document = deepcopy(wldoc)
 454     del wldoc
 455
 456     if flags:
 457         for flag in flags:
 458             document.edoc.getroot().set(flag, 'yes')
 459
 460     # add editors info
 461     document.edoc.getroot().set('editors', u', '.join(sorted(
 462         editor.readable() for editor in document.editors())))
 463     if document.book_info.funders:
 464         document.edoc.getroot().set('funders', u', '.join(
 465             document.book_info.funders))
 466     if document.book_info.thanks:
 467         document.edoc.getroot().set('thanks', document.book_info.thanks)
 468
 469     opf = xslt(document.book_info.to_etree(), get_resource('epub/xsltContent.xsl'))
 470     manifest = opf.find('.//' + OPFNS('manifest'))
 471     guide = opf.find('.//' + OPFNS('guide'))
 472     spine = opf.find('.//' + OPFNS('spine'))
 473
 474     output_file = NamedTemporaryFile(prefix='librarian', suffix='.epub', delete=False)
 475     zip = zipfile.ZipFile(output_file, 'w', zipfile.ZIP_DEFLATED)
 476
 477     # write static elements
 478     mime = zipfile.ZipInfo()
 479     mime.filename = 'mimetype'
 480     mime.compress_type = zipfile.ZIP_STORED
 481     mime.extra = ''
 482     zip.writestr(mime, 'application/epub+zip')
 483     zip.writestr('META-INF/container.xml', '<?xml version="1.0" ?><container version="1.0" ' \
 484                        'xmlns="urn:oasis:names:tc:opendocument:xmlns:container">' \
 485                        '<rootfiles><rootfile full-path="OPS/content.opf" ' \
 486                        'media-type="application/oebps-package+xml" />' \
 487                        '</rootfiles></container>')
 488     zip.write(get_resource('res/wl-logo-small.png'), os.path.join('OPS', 'logo_wolnelektury.png'))
 489     zip.write(get_resource('res/jedenprocent.png'), os.path.join('OPS', 'jedenprocent.png'))
 490     if not style:
 491         style = get_resource('epub/style.css')
 492     zip.write(style, os.path.join('OPS', 'style.css'))
 493
 494     if cover:
 495         if cover is True:
 496             cover = DefaultEbookCover
 497
 498         cover_file = StringIO()
 499         bound_cover = cover(document.book_info)
 500         bound_cover.save(cover_file)
 501         cover_name = 'cover.%s' % bound_cover.ext()
 502         zip.writestr(os.path.join('OPS', cover_name), cover_file.getvalue())
 503         del cover_file
 504
 505         cover_tree = etree.parse(get_resource('epub/cover.html'))
 506         cover_tree.find('//' + XHTMLNS('img')).set('src', cover_name)
 507         zip.writestr('OPS/cover.html', etree.tostring(
 508                         cover_tree, method="html", pretty_print=True))
 509
 510         if bound_cover.uses_dc_cover:
 511             if document.book_info.cover_by:
 512                 document.edoc.getroot().set('data-cover-by', document.book_info.cover_by)
 513             if document.book_info.cover_source:
 514                 document.edoc.getroot().set('data-cover-source', document.book_info.cover_source)
 515
 516         manifest.append(etree.fromstring(
 517             '<item id="cover" href="cover.html" media-type="application/xhtml+xml" />'))
 518         manifest.append(etree.fromstring(
 519             '<item id="cover-image" href="%s" media-type="%s" />' % (cover_name, bound_cover.mime_type())))
 520         spine.insert(0, etree.fromstring('<itemref idref="cover"/>'))
 521         opf.getroot()[0].append(etree.fromstring('<meta name="cover" content="cover-image"/>'))
 522         guide.append(etree.fromstring('<reference href="cover.html" type="cover" title="Okładka"/>'))
 523
 524
 525     annotations = etree.Element('annotations')
 526
 527     toc_file = etree.fromstring('<?xml version="1.0" encoding="utf-8"?><!DOCTYPE ncx PUBLIC ' \
 528                                '"-//NISO//DTD ncx 2005-1//EN" "http://www.daisy.org/z3986/2005/ncx-2005-1.dtd">' \
 529                                '<ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" xml:lang="pl" ' \
 530                                'version="2005-1"><head></head><docTitle></docTitle><navMap>' \
 531                                '</navMap></ncx>')
 532     nav_map = toc_file[-1]
 533
 534     if html_toc:
 535         manifest.append(etree.fromstring(
 536             '<item id="html_toc" href="toc.html" media-type="application/xhtml+xml" />'))
 537         spine.append(etree.fromstring(
 538             '<itemref idref="html_toc" />'))
 539         guide.append(etree.fromstring('<reference href="toc.html" type="toc" title="Spis treści"/>'))
 540
 541     toc, chunk_counter, chars, sample = transform_file(document, sample=sample)
 542
 543     if len(toc.children) < 2:
 544         toc.add(u"Początek utworu", "part1.html")
 545
 546     # Last modifications in container files and EPUB creation
 547     if len(annotations) > 0:
 548         toc.add("Przypisy", "annotations.html")
 549         manifest.append(etree.fromstring(
 550             '<item id="annotations" href="annotations.html" media-type="application/xhtml+xml" />'))
 551         spine.append(etree.fromstring(
 552             '<itemref idref="annotations" />'))
 553         replace_by_verse(annotations)
 554         html_tree = xslt(annotations, get_resource('epub/xsltAnnotations.xsl'))
 555         chars = chars.union(used_chars(html_tree.getroot()))
 556         zip.writestr('OPS/annotations.html', etree.tostring(
 557                             html_tree, method="html", pretty_print=True))
 558
 559     toc.add("Wesprzyj Wolne Lektury", "support.html")
 560     manifest.append(etree.fromstring(
 561         '<item id="support" href="support.html" media-type="application/xhtml+xml" />'))
 562     spine.append(etree.fromstring(
 563         '<itemref idref="support" />'))
 564     html_string = open(get_resource('epub/support.html')).read()
 565     chars.update(used_chars(etree.fromstring(html_string)))
 566     zip.writestr('OPS/support.html', html_string)
 567
 568     toc.add("Strona redakcyjna", "last.html")
 569     manifest.append(etree.fromstring(
 570         '<item id="last" href="last.html" media-type="application/xhtml+xml" />'))
 571     spine.append(etree.fromstring(
 572         '<itemref idref="last" />'))
 573     html_tree = xslt(document.edoc, get_resource('epub/xsltLast.xsl'))
 574     chars.update(used_chars(html_tree.getroot()))
 575     zip.writestr('OPS/last.html', etree.tostring(
 576                         html_tree, method="html", pretty_print=True))
 577
 578     if not flags or not 'without-fonts' in flags:
 579         # strip fonts
 580         tmpdir = mkdtemp('-librarian-epub')
 581         try:
 582             cwd = os.getcwd()
 583         except OSError:
 584             cwd = None
 585
 586         os.chdir(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'font-optimizer'))
 587         for fname in 'DejaVuSerif.ttf', 'DejaVuSerif-Bold.ttf', 'DejaVuSerif-Italic.ttf', 'DejaVuSerif-BoldItalic.ttf':
 588             if not flags or not 'with-full-fonts' in flags:
 589                 optimizer_call = ['perl', 'subset.pl', '--chars', ''.join(chars).encode('utf-8'),
 590                               get_resource('fonts/' + fname), os.path.join(tmpdir, fname)]
 591                 if verbose:
 592                     print "Running font-optimizer"
 593                     subprocess.check_call(optimizer_call)
 594                 else:
 595                     subprocess.check_call(optimizer_call, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 596                     zip.write(os.path.join(tmpdir, fname), os.path.join('OPS', fname))
 597             else:
 598                 zip.write(get_resource('fonts/' + fname), os.path.join('OPS', fname))
 599             manifest.append(etree.fromstring(
 600                 '<item id="%s" href="%s" media-type="application/x-font-truetype" />' % (fname, fname)))
 601         rmtree(tmpdir)
 602         if cwd is not None:
 603             os.chdir(cwd)
 604     zip.writestr('OPS/content.opf', etree.tostring(opf, pretty_print=True, xml_declaration = True, encoding='UTF-8'))
 605     title = document.book_info.title
 606     attributes = "dtb:uid", "dtb:depth", "dtb:totalPageCount", "dtb:maxPageNumber"
 607     for st in attributes:
 608         meta = toc_file.makeelement(NCXNS('meta'))
 609         meta.set('name', st)
 610         meta.set('content', '0')
 611         toc_file[0].append(meta)
 612     toc_file[0][0].set('content', str(document.book_info.url))
 613     toc_file[0][1].set('content', str(toc.depth()))
 614     set_inner_xml(toc_file[1], ''.join(('<text>', title, '</text>')))
 615
 616     # write TOC
 617     if html_toc:
 618         toc.add(u"Spis treści", "toc.html", index=1)
 619         zip.writestr('OPS/toc.html', toc.html().encode('utf-8'))
 620     toc.write_to_xml(nav_map)
 621     zip.writestr('OPS/toc.ncx', etree.tostring(toc_file, pretty_print=True, xml_declaration = True, encoding='UTF-8'))
 622     zip.close()
 623
 624     return OutputFile.from_filename(output_file.name)