pad prefix
[redakcja.git] / apps / catalogue / management / edumed.py
1 # EduMed auto-tagger
2 # -*- coding: utf-8 -*-
3 import re
4 from slughifi import slughifi
5
6
7 class Tagger(object):
8     def __init__(self, state, lines):
9         self.state = state
10         self.lines = lines
11
12     def spawn(self, cls):
13         return cls(self.state, self.lines)
14
15     def line(self, position):
16         return self.lines[position]
17
18     ignore = [re.compile(r"^[\[][PA][\]] - [^ ]+$")]
19     empty_line = re.compile(r"^\s+$")
20
21     def skip_empty(self, position):
22         while self.line(position) == "" or \
23             self.empty_line.match(self.line(position)) or \
24             filter(lambda r: r.match(self.line(position)),
25                              self.ignore[:]):
26             position += 1
27         return position
28
29     def tag(self, position):
30         """
31 Return None -- means that we can't tag it in any way
32         """
33         return None
34
35     def wrap(self, tagname, content):
36         return u"<%s>%s</%s>" % (tagname, content, tagname)
37
38     @staticmethod
39     def anymatches(regex):
40         return lambda x: regex.match(x)
41
42
43 class Section(Tagger):
44     looks_like = re.compile(r"^[IVX]+[.]\s+(.*)$")
45
46     def __init__(self, *a):
47         super(Section, self).__init__(*a)
48         self.is_podrozdzial = False
49
50     def tag(self, pos):
51         pos2 = self.skip_empty(pos)
52         pos = pos2
53         m = self.looks_like.match(self.line(pos))
54         if m:
55             self.title = m.groups()[0]
56             return pos + 1
57
58     def __unicode__(self):
59         return self.wrap(self.is_podrozdzial and "naglowek_podrozdzial" or "naglowek_rozdzial",
60                          self.title)
61
62
63 class Meta(Tagger):
64     looks_like = re.compile(r"([^:]+): (.*)", re.UNICODE)
65
66     def tag(self, pos):
67         pos = self.skip_empty(pos)
68         m = self.looks_like.match(self.line(pos))
69         if m:
70             k = m.groups()[0]
71             v = m.groups()[1]
72             m = self.state.get('meta', {})
73             m[k] = v
74             self.state['meta'] = m
75             return pos + 1
76
77
78 class Informacje(Tagger):
79     def tag(self, pos):
80         self.title = self.spawn(Section)
81         self.meta = []
82         pos = self.title.tag(pos)
83         if pos is None: return
84
85             # collect meta
86         while True:
87             pos = self.skip_empty(pos)
88             meta = self.spawn(Meta)
89             pos2 = meta.tag(pos)
90             if pos2 is None: break
91             self.meta.append(meta)
92             pos = pos2
93
94         return pos
95
96
97 class List(Tagger):
98     point = re.compile(r"^[\s]*[-*·]{1,2}(.*)")
99     num = re.compile(r"^[\s]*[a-z][.]\s+(.*)")
100
101     def __init__(self, *args):
102
103         super(List, self).__init__(*args)
104         self.items = []
105         self.type = 'punkt'
106
107     def tag(self, pos):
108         while True:
109             l = self.line(pos)
110             m = self.point.match(l)
111             if not m:
112                 m = self.num.match(l)
113                 if m: self.type = 'num'
114             if l and m:
115                 self.items.append(m.groups()[0].lstrip())
116                 pos += 1
117             else:
118                 break
119         if self.items:
120             return pos
121
122     def append(self, tagger):
123         self.items.append(tagger)
124
125     def __unicode__(self):
126         s = '<lista typ="%s">' % self.type
127         for i in self.items:
128             if isinstance(i, list):
129                 x = "\n".join(map(lambda elem: unicode(elem), i))
130             else:
131                 x = unicode(i)
132             s += "\n<punkt>%s</punkt>" % x
133         s += "\n</lista>\n"
134         return s
135
136
137 class Paragraph(Tagger):
138     remove_this = [
139         re.compile(r"[\s]*opis zawarto.ci[\s]*", re.I),
140         re.compile(r"^[\s]*$"),
141         re.compile(r"http://pad.nowoczesnapolska.org.pl/p/slowniczek")
142         ]
143     podrozdzial = [
144         re.compile(r"[\s]*(przebieg zaj..|opcje dodatkowe)[\s]*", re.I),
145         ]
146
147     def tag(self, pos):
148         self.line = self.lines[pos]
149         self.ignore = False
150         self.is_podrozdzial = False
151
152         for x in self.remove_this:
153             if x.match(self.line):
154                 self.ignore = True
155
156         for x in self.podrozdzial:
157             if x.match(self.line):
158                 self.is_podrozdzial = True
159
160         return pos + 1
161
162     def __unicode__(self):
163         if not self.ignore:
164             if self.is_podrozdzial:
165                 tag = 'naglowek_podrozdzial'
166             else:
167                 tag = 'akap'
168             return u"<%s>%s</%s>" % (tag, self.line, tag)
169         else:
170             return u''
171
172
173 class Container:
174     def __init__(self, tag_name, *elems):
175         self.tag_name = tag_name
176         self.elems = elems
177
178     def __unicode__(self):
179         s = u"<%s>" % self.tag_name
180         add_nl = False
181         for e in self.elems:
182             if isinstance(e, (str, unicode)):
183                 s += unicode(e)
184             else:
185                 s += "\n  " + unicode(e)
186                 add_nl = True
187
188         if add_nl: s += "\n"
189         s += u"</%s>" % self.tag_name
190         return s
191
192
193 def eatany(pos, *taggers):
194     try:
195         for t in list(taggers):
196             p = t.tag(pos)
197             if p:
198                 return (t, p)
199     except IndexError:
200         pass
201     return (None, pos)
202
203
204 def eatseq(pos, *taggers):
205     good = []
206     taggers = list(taggers[:])
207     try:
208         while len(taggers):
209             p = taggers[0].tag(pos)
210             if p is None:
211                 return (tuple(good), pos)
212             good.append(taggers.pop(0))
213             # print "%d -> %d" % (pos, p)
214             pos = p
215
216     except IndexError:
217         print "Got index error for pos=%d" % pos
218     return (tuple(good), pos)
219
220
221 def tagger(text, pretty_print=False):
222     """
223 tagger(text) function name and signature is a contract.
224 returns auto-tagged text
225     """
226     if not isinstance(text, unicode):
227         text = unicode(text.decode('utf-8'))
228     lines = text.split("\n")
229     pos = 0
230     content = []
231     state = {}
232     info = Informacje(state, lines)
233
234     ((info,), pos) = eatseq(pos, info)
235
236     # print "[i] %d. %s" % (pos, lines[pos])
237
238     content.append(info)
239
240     while True:
241         x, pos = eatany(pos, info.spawn(Section),
242                         info.spawn(List), info.spawn(Paragraph))
243
244         if x is not None:
245             content.append(x)
246         else:
247             content.append(lines[pos])
248             pos += 1
249             if pos >= len(lines):
250                 break
251
252     return toxml(content, pretty_print=pretty_print)
253
254 dc_fixed = {
255     'description': u'Publikacja zrealizowana w ramach projektu Cyfrowa Przyszłość (http://cyfrowaprzyszlosc.pl).',
256     'relation': u'moduły powiązane linki',
257     'description.material': u'linki do załączników',
258     'rights': u'Creative Commons Uznanie autorstwa - Na tych samych warunkach 3.0',
259     }
260
261
262 class NotFound(Exception):
263     pass
264
265
266 def find_block(content, title_re, begin=-1, end=-1):
267     title_re = re.compile(title_re, re.I | re.UNICODE)
268
269     rb = -1
270     if begin < 0: begin = 0
271     if end < 0: end = len(content)
272
273     for i in range(begin, end):
274         elem = content[i]
275         if isinstance(elem, Paragraph):
276             if title_re.match(elem.line):
277                 rb = i
278                 continue
279         if isinstance(elem, Section):
280             if title_re.match(elem.title):
281                 rb = i
282                 continue
283         if rb >= 0:
284             if isinstance(elem, List):
285                 continue
286             if isinstance(elem, Paragraph) and elem.line:
287                 continue
288             break
289     if rb >= 0:
290         return rb, i
291     raise NotFound()
292
293
294 def remove_block(content, title_re, removed=None):
295     rb, re = find_block(content, title_re)
296     if removed is not None and isinstance(removed, list):
297         removed += content[rb:re][:]
298     content[rb:re] = []
299     return content
300
301
302 def mark_activities(content):
303     i = 0
304     tl = len(content)
305     is_przebieg = re.compile(r"[\s]*przebieg zaj..[\s]*", re.I)
306
307     is_next_section = re.compile(r"^[IVX]+[.]? ")
308     is_activity = re.compile(r"^[0-9]+[.] (.+)")
309
310     is_activity_tools = re.compile(r"^pomoce:[\s]*(.+)")
311     is_activity_work = re.compile(r"^forma pracy:[\s]*(.+)")
312     is_activity_time = re.compile(r"^czas:[\s]*([\d]+).*")
313     activity_props = {
314         'pomoce': is_activity_tools,
315         'forma': is_activity_work,
316         'czas': is_activity_time
317         }
318     activities = []
319
320     in_activities = False
321     ab = -1
322     ae = -1
323     while True:
324         e = content[i]
325         if isinstance(e, Section):
326             if in_activities and \
327                 is_next_section.match(e.title):
328                 in_activities = False
329             
330         if isinstance(e, Paragraph):
331             if not in_activities and \
332                 is_przebieg.match(e.line):
333                 in_activities = True
334
335             if in_activities:
336                 m = is_activity.match(e.line)
337                 if m:
338                     e.line = m.groups()[0]
339                     ab = i
340                 if is_activity_time.match(e.line):
341                     ae = i + 1
342                     activities.append((ab, ae))
343         i += 1
344         if i >= tl: break
345
346     activities.reverse()
347     for ab, ae in activities:
348         act_len = ae - ab
349         info_start = ae
350
351         act_els = []
352         act_els.append(Container("opis", content[ab]))
353         for i in range(ab, ae):
354             e = content[i]
355             if isinstance(e, Paragraph):
356                 for prop, pattern in activity_props.items():
357                     m = pattern.match(e.line)
358                     if m:
359                         act_els.append(Container(prop, m.groups()[0]))
360                         if info_start > i: info_start = i
361         act_els.insert(1, Container('wskazowki',
362                                     *content[ab + 1:info_start]))
363         content[ab:ae] = [Container('aktywnosc', *act_els)]
364     return content
365
366
367 def mark_dictionary(content):
368     db = -1
369     de = -1
370     i = 0
371     is_dictionary = re.compile(r"[\s]*s.owniczek[\s]*", re.I)
372     is_dictentry = re.compile(r"([^-]+) - (.+)")
373     slowniczek = content[0].spawn(List)
374     slowniczek.type = 'slowniczek'
375     while i < len(content):
376         e = content[i]
377         if isinstance(e, Section):
378             if is_dictionary.match(e.title):
379                 db = i + 1
380             elif db >= 1:
381                 de = i
382                 content[db:de] = [slowniczek]
383                 break
384         elif db >= 0:
385             if isinstance(e, Paragraph):
386                 m = is_dictentry.match(e.line)
387                 if m:
388                     slowniczek.append([Container('definiendum', m.groups()[0]),
389                                        Container('definiens', m.groups()[1])])
390
391                 else:
392                     slowniczek.append(e)
393         i += 1
394
395     return content
396
397
398 def move_evaluation(content):
399     evaluation = []
400
401     content = remove_block(content, r"ewaluacja[+ PA\[\].]*", evaluation)
402     if evaluation:
403         #        print "found evaluation %s" % (evaluation,)
404         evaluation[0].is_podrozdzial = True
405         # evaluation place
406         opcje_dodatkowe = find_block(content, r"opcje dodatkowe\s*")
407         if opcje_dodatkowe:
408             #            print "putting evaluation just before opcje dodatkowe @ %s" % (opcje_dodatkowe, )
409             content[opcje_dodatkowe[0]:opcje_dodatkowe[0]] = evaluation
410         else:
411             materialy = find_block(content, r"materia.y[+ AP\[\].]*")
412             if materialy:
413                 #                print "putting evaluation just before materialy @ %s" % (materialy, )
414                 content[materialy[0]:materialy[0]] = evaluation
415             else:
416                 print "er.. no idea where to place evaluation"
417     return content
418
419
420 def toxml(content, pretty_print=False):
421     # some transformations
422     content = mark_activities(content)
423     content = mark_dictionary(content)
424     try:
425         content = remove_block(content, r"wykorzyst(yw)?ane metody[+ PA\[\].]*")
426     except NotFound:
427         pass
428     try:
429         content = remove_block(content, r"(pomoce|potrzebne materia.y)[+ PA\[\]]*")
430     except NotFound:
431         pass
432     content = move_evaluation(content)
433
434     info = content.pop(0)
435
436     state = info.state
437     meta = state['meta']
438     slug = slughifi(meta.get(u'Tytuł modułu', ''))
439     holder = {}
440     holder['xml'] = u""
441
442     def p(t):
443         holder['xml'] += u"%s\n" % t
444
445     def dc(k, v):
446         p(u'<dc:%s xml:lang="pl" xmlns:dc="http://purl.org/dc/elements/1.1/">%s</dc:%s>' % (k, v, k))
447
448     def t(tag, ct):
449         p(u'<%s>%s</%s>' % (tag, ct, tag))
450
451     def a(ct):
452         if ct:
453             t(u'akap', ct)
454
455     p("<utwor>")
456     p(u'<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">')
457     p(u'<rdf:Description rdf:about="http://redakcja.cyfrowaprzyszlosc.pl/documents/">')
458     authors = map(unicode.strip, meta[u'Autorzy'].split(u','))
459     for author in authors:
460         names = author.split(u' ')
461         lastname = names.pop()
462         names.insert(0, lastname + ",")
463         author = u' '.join(names)
464         dc(u'creator', author)
465     dc(u'title', meta.get(u'Tytuł modułu', u''))
466     dc(u'relation.isPartOf', meta.get(u'Dział', u''))
467     dc(u'publisher', u'Fundacja Nowoczesna Polska')
468     dc(u'subject.competence', meta.get(u'Wybrana kompetencja z Katalogu', u''))
469     dc(u'subject.curriculum', meta.get(u'Odniesienie do podstawy programowej', u''))
470     for keyword in meta.get(u'Słowa kluczowe', u'').split(u','):
471         keyword = keyword.strip()
472         dc(u'subject', keyword)
473     dc(u'description', dc_fixed['description'])
474     dc(u'description.material', dc_fixed['description.material'])
475     dc(u'relation', dc_fixed['relation'])
476     dc(u'identifier.url', u'http://cyfrowaprzyszlosc.pl/%s' % slug)
477     dc(u'rights', dc_fixed['rights'])
478     dc(u'rights.license', u'http://creativecommons.org/licenses/by-sa/3.0/')
479     dc(u'format', u'xml')
480     dc(u'type', u'text')
481     dc(u'date', u'2012-11-09')  # TODO
482     dc(u'audience', meta.get(u'Poziom edukacyjny', u''))
483     dc(u'language', u'pol')
484     p(u'</rdf:Description>')
485     p(u'</rdf:RDF>')
486
487     p(u'<powiesc>')
488     t(u'nazwa_utworu', meta.get(u'Tytuł modułu', u''))
489     #    p(u'<nota>')
490     a(u'<!-- Numer porządkowy: %s -->' % meta.get(u'Numer porządkowy', u''))
491     #    p(u'</nota>')
492
493     p(unicode(info.title))
494     for elm in content:
495         if isinstance(elm, unicode) or isinstance(elm, str):
496             a(elm)
497             continue
498         p(unicode(elm))
499
500     p(u'</powiesc>')
501     p(u'</utwor>')
502
503     if pretty_print:
504         from lxml import etree
505         from StringIO import StringIO
506         xml = etree.parse(StringIO(holder['xml']))
507         holder['xml'] = etree.tostring(xml, pretty_print=pretty_print, encoding=unicode)
508
509     return holder['xml']
510
511
512 # TODO / TBD
513 # ogarnąć podrozdziały
514 #  Przebieg zajęć
515 #  opcje dodatkowe
516 # usunąć 'opis zawartości'
517 # akapit łączony?