Make sure Pillow uses ImageFont.LAYOUT_BASIC because of https://github.com/python...
[librarian.git] / src / librarian / parser.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 unicode_literals
7
8 from librarian import ValidationError, NoDublinCore,  ParseError, NoProvider
9 from librarian import RDFNS
10 from librarian.cover import make_cover
11 from librarian import dcparser
12
13 from xml.parsers.expat import ExpatError
14 from lxml import etree
15 from lxml.etree import XMLSyntaxError, XSLTApplyError
16
17 import os
18 import re
19 import six
20
21
22 from .elements import WL_ELEMENTS
23
24
25 class WLElementLookup(etree.CustomElementClassLookup):
26     def lookup(self, node_type, document, namespace, name):
27         if node_type != 'element':
28             return
29         if namespace:
30             return
31         return WL_ELEMENTS[name]
32
33
34 parser = etree.XMLParser()
35 parser.set_element_class_lookup(
36     WLElementLookup()
37 )
38
39
40
41 class WLDocument(object):
42     """Legacy class, to be replaced with documents.WLDocument."""
43     LINE_SWAP_EXPR = re.compile(r'/\s', re.MULTILINE | re.UNICODE)
44     provider = None
45
46     def __init__(self, edoc, parse_dublincore=True, provider=None,
47                  strict=False, meta_fallbacks=None):
48         self.edoc = edoc
49         self.provider = provider
50
51         root_elem = edoc.getroot()
52
53         dc_path = './/' + RDFNS('RDF')
54
55         if root_elem.tag != 'utwor':
56             raise ValidationError(
57                 "Invalid root element. Found '%s', should be 'utwor'"
58                 % root_elem.tag
59             )
60
61         if parse_dublincore:
62             self.rdf_elem = root_elem.find(dc_path)
63
64             if self.rdf_elem is None:
65                 raise NoDublinCore(
66                     "Document must have a '%s' element." % RDFNS('RDF')
67                 )
68
69             self.book_info = dcparser.BookInfo.from_element(
70                 self.rdf_elem, fallbacks=meta_fallbacks, strict=strict)
71         else:
72             self.book_info = None
73
74     @classmethod
75     def from_bytes(cls, xml, *args, **kwargs):
76         return cls.from_file(six.BytesIO(xml), *args, **kwargs)
77
78     @classmethod
79     def from_file(cls, xmlfile, *args, **kwargs):
80
81         # first, prepare for parsing
82         if isinstance(xmlfile, six.text_type):
83             file = open(xmlfile, 'rb')
84             try:
85                 data = file.read()
86             finally:
87                 file.close()
88         else:
89             data = xmlfile.read()
90
91         if not isinstance(data, six.text_type):
92             data = data.decode('utf-8')
93
94         data = data.replace(u'\ufeff', '')
95
96         try:
97             parser = etree.XMLParser(remove_blank_text=False)
98             tree = etree.parse(six.BytesIO(data.encode('utf-8')), parser)
99
100             return cls(tree, *args, **kwargs)
101         except (ExpatError, XMLSyntaxError, XSLTApplyError) as e:
102             raise ParseError(e)
103
104     def swap_endlines(self):
105         """Converts line breaks in stanzas into <br/> tags."""
106         # only swap inside stanzas
107         for elem in self.edoc.iter('strofa'):
108             for child in list(elem):
109                 if child.tail:
110                     chunks = self.LINE_SWAP_EXPR.split(child.tail)
111                     ins_index = elem.index(child) + 1
112                     while len(chunks) > 1:
113                         ins = etree.Element('br')
114                         ins.tail = chunks.pop()
115                         elem.insert(ins_index, ins)
116                     child.tail = chunks.pop(0)
117             if elem.text:
118                 chunks = self.LINE_SWAP_EXPR.split(elem.text)
119                 while len(chunks) > 1:
120                     ins = etree.Element('br')
121                     ins.tail = chunks.pop()
122                     elem.insert(0, ins)
123                 elem.text = chunks.pop(0)
124
125     def parts(self):
126         if self.provider is None:
127             raise NoProvider('No document provider supplied.')
128         if self.book_info is None:
129             raise NoDublinCore('No Dublin Core in document.')
130         for part_uri in self.book_info.parts:
131             yield self.from_file(
132                 self.provider.by_uri(part_uri), provider=self.provider
133             )
134
135     def chunk(self, path):
136         # convert the path to XPath
137         expr = self.path_to_xpath(path)
138         elems = self.edoc.xpath(expr)
139
140         if len(elems) == 0:
141             return None
142         else:
143             return elems[0]
144
145     def path_to_xpath(self, path):
146         parts = []
147
148         for part in path.split('/'):
149             match = re.match(r'([^\[]+)\[(\d+)\]', part)
150             if not match:
151                 parts.append(part)
152             else:
153                 tag, n = match.groups()
154                 parts.append("*[%d][name() = '%s']" % (int(n)+1, tag))
155
156         if parts[0] == '.':
157             parts[0] = ''
158
159         return '/'.join(parts)
160
161     def transform(self, stylesheet, **options):
162         return self.edoc.xslt(stylesheet, **options)
163
164     def update_dc(self):
165         if self.book_info:
166             parent = self.rdf_elem.getparent()
167             parent.replace(self.rdf_elem, self.book_info.to_etree(parent))
168
169     def serialize(self):
170         self.update_dc()
171         return etree.tostring(self.edoc, encoding='unicode', pretty_print=True)
172
173     def merge_chunks(self, chunk_dict):
174         unmerged = []
175
176         for key, data in chunk_dict.iteritems():
177             try:
178                 xpath = self.path_to_xpath(key)
179                 node = self.edoc.xpath(xpath)[0]
180                 repl = etree.fromstring(
181                     "<%s>%s</%s>" % (node.tag, data, node.tag)
182                 )
183                 node.getparent().replace(node, repl)
184             except Exception as e:
185                 unmerged.append(repr((key, xpath, e)))
186
187         return unmerged
188
189     def clean_ed_note(self, note_tag='nota_red'):
190         """ deletes forbidden tags from nota_red """
191
192         for node in self.edoc.xpath('|'.join(
193                 '//%s//%s' % (note_tag, tag) for tag in
194                 ('pa', 'pe', 'pr', 'pt', 'begin', 'end', 'motyw'))):
195             tail = node.tail
196             node.clear()
197             node.tag = 'span'
198             node.tail = tail
199
200     def editors(self):
201         """Returns a set of all editors for book and its children.
202
203         :returns: set of dcparser.Person objects
204         """
205         if self.book_info is None:
206             raise NoDublinCore('No Dublin Core in document.')
207         persons = set(self.book_info.editors
208                       + self.book_info.technical_editors)
209         for child in self.parts():
210             persons.update(child.editors())
211         if None in persons:
212             persons.remove(None)
213         return persons
214
215     # Converters
216
217     def as_html(self, *args, **kwargs):
218         from librarian import html
219         return html.transform(self, *args, **kwargs)
220
221     def as_text(self, *args, **kwargs):
222         from librarian import text
223         return text.transform(self, *args, **kwargs)
224
225     def as_epub(self, *args, **kwargs):
226         from librarian import epub
227         return epub.transform(self, *args, **kwargs)
228
229     def as_pdf(self, *args, **kwargs):
230         from librarian import pdf
231         return pdf.transform(self, *args, **kwargs)
232
233     def as_mobi(self, *args, **kwargs):
234         from librarian import mobi
235         return mobi.transform(self, *args, **kwargs)
236
237     def as_fb2(self, *args, **kwargs):
238         from librarian import fb2
239         return fb2.transform(self, *args, **kwargs)
240
241     def as_cover(self, cover_class=None, *args, **kwargs):
242         if cover_class is None:
243             cover_class = make_cover
244         return cover_class(self.book_info, *args, **kwargs).output_file()
245
246     # for debugging only
247     def latex_dir(self, *args, **kwargs):
248         kwargs['latex_dir'] = True
249         from librarian import pdf
250         return pdf.transform(self, *args, **kwargs)
251
252     def save_output_file(self, output_file, output_path=None,
253                          output_dir_path=None, make_author_dir=False,
254                          ext=None):
255         if output_dir_path:
256             save_path = output_dir_path
257             if make_author_dir:
258                 save_path = os.path.join(
259                     save_path,
260                     six.text_type(self.book_info.author).encode('utf-8')
261                 )
262             save_path = os.path.join(save_path, self.book_info.url.slug)
263             if ext:
264                 save_path += '.%s' % ext
265         else:
266             save_path = output_path
267
268         output_file.save_as(save_path)