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