b3b704d0bf715d00f0e4727a1636a7be5dee1541
[wolnelektury.git] / src / search / custom.py
1 # -*- coding: utf-8 -*-
2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
4 #
5 from sunburnt import sunburnt
6 from lxml import etree
7 import urllib
8 import warnings
9 from sunburnt import search
10 import copy
11 from httplib2 import socket
12 import re
13
14
15 class TermVectorOptions(search.Options):
16     def __init__(self, schema, original=None):
17         self.schema = schema
18         if original is None:
19             self.fields = set()
20             self.positions = False
21         else:
22             self.fields = copy.copy(original.fields)
23             self.positions = copy.copy(original.positions)
24
25     def update(self, positions=False, fields=None):
26         if fields is None:
27             fields = []
28         if isinstance(fields, basestring):
29             fields = [fields]
30         self.schema.check_fields(fields, {"stored": True})
31         self.fields.update(fields)
32         self.positions = positions
33
34     def options(self):
35         opts = {}
36         if self.positions or self.fields:
37             opts['tv'] = 'true'
38         if self.positions:
39             opts['tv.positions'] = 'true'
40         if self.fields:
41             opts['tv.fl'] = ','.join(sorted(self.fields))
42         return opts
43
44
45 class CustomSolrConnection(sunburnt.SolrConnection):
46     def __init__(self, *args, **kw):
47         super(CustomSolrConnection, self).__init__(*args, **kw)
48         self.analysis_url = self.url + "analysis/field/"
49
50     def analyze(self, params):
51         qs = urllib.urlencode(params)
52         url = "%s?%s" % (self.analysis_url, qs)
53         if len(url) > self.max_length_get_url:
54             warnings.warn("Long query URL encountered - POSTing instead of "
55                 "GETting. This query will not be cached at the HTTP layer")
56             url = self.analysis_url
57             kwargs = dict(
58                 method="POST",
59                 body=qs,
60                 headers={"Content-Type": "application/x-www-form-urlencoded"},
61             )
62         else:
63             kwargs = dict(method="GET")
64         r, c = self.request(url, **kwargs)
65         if r.status != 200:
66             raise sunburnt.SolrError(r, c)
67         return c
68
69
70 # monkey patching sunburnt SolrSearch
71 search.SolrSearch.option_modules += ('term_vectorer',)
72
73
74 def __term_vector(self, positions=False, fields=None):
75     newself = self.clone()
76     newself.term_vectorer.update(positions, fields)
77     return newself
78 setattr(search.SolrSearch, 'term_vector', __term_vector)
79
80
81 def __patched__init_common_modules(self):
82     __original__init_common_modules(self)
83     self.term_vectorer = TermVectorOptions(self.schema)
84 __original__init_common_modules = search.SolrSearch._init_common_modules
85 setattr(search.SolrSearch, '_init_common_modules', __patched__init_common_modules)
86
87
88 class CustomSolrInterface(sunburnt.SolrInterface):
89     # just copied from parent and SolrConnection -> CustomSolrConnection
90     def __init__(self, url, schemadoc=None, http_connection=None, mode='', retry_timeout=-1, max_length_get_url=sunburnt.MAX_LENGTH_GET_URL):
91         self.conn = CustomSolrConnection(url, http_connection, retry_timeout, max_length_get_url)
92         self.schemadoc = schemadoc
93         if 'w' not in mode:
94             self.writeable = False
95         elif 'r' not in mode:
96             self.readable = False
97         try:
98             self.init_schema()
99         except socket.error, e:
100             raise socket.error, "Cannot connect to Solr server, and search indexing is enabled (%s)" % str(e)
101
102     def _analyze(self, **kwargs):
103         if not self.readable:
104             raise TypeError("This Solr instance is only for writing")
105         args = {
106             'analysis_showmatch': True
107             }
108         if 'field' in kwargs: args['analysis_fieldname'] = kwargs['field']
109         if 'text' in kwargs: args['analysis_fieldvalue'] = kwargs['text']
110         if 'q' in kwargs: args['q'] = kwargs['q']
111         if 'query' in kwargs: args['q'] = kwargs['q']
112
113         params = map(lambda (k, v): (k.replace('_', '.'), v), sunburnt.params_from_dict(**args))
114
115         content = self.conn.analyze(params)
116         doc = etree.fromstring(content)
117         return doc
118
119     def highlight(self, **kwargs):
120         doc = self._analyze(**kwargs)
121         analyzed = doc.xpath("//lst[@name='index']/arr[last()]/lst[bool/@name='match']")
122         matches = set()
123         for wrd in analyzed:
124             start = int(wrd.xpath("int[@name='start']")[0].text)
125             end = int(wrd.xpath("int[@name='end']")[0].text)
126             matches.add((start, end))
127
128         if matches:
129             return self.substring(kwargs['text'], matches,
130                 margins=kwargs.get('margins', 30),
131                 mark=kwargs.get('mark', ("<b>", "</b>")))
132         else:
133             return None
134
135     def analyze(self, **kwargs):
136         doc = self._analyze(**kwargs)
137         terms = doc.xpath("//lst[@name='index']/arr[last()]/lst/str[1]")
138         terms = map(lambda n: unicode(n.text), terms)
139         return terms
140
141     def expand_margins(self, text, start, end):
142         totlen = len(text)
143
144         def is_boundary(x):
145             ws = re.compile(r"\W", re.UNICODE)
146             return bool(ws.match(x))
147
148         while start > 0:
149             if is_boundary(text[start - 1]):
150                 break
151             start -= 1
152
153         while end < totlen - 1:
154             if is_boundary(text[end + 1]):
155                 break
156             end += 1
157
158         return (start, end)
159
160     def substring(self, text, matches, margins=30, mark=("<b>", "</b>")):
161         start = None
162         end = None
163         totlen = len(text)
164         matches_margins = map(lambda (s, e):
165                               ((s, e),
166                                (max(0, s - margins), min(totlen, e + margins))),
167                                   matches)
168         matches_margins = map(lambda (m, (s, e)):
169                               (m, self.expand_margins(text, s, e)),
170             matches_margins)
171
172             # lets start with first match
173         (start, end) = matches_margins[0][1]
174         matches = [matches_margins[0][0]]
175
176         for (m, (s, e)) in matches_margins[1:]:
177             if end < s or start > e:
178                 continue
179             start = min(start, s)
180             end = max(end, e)
181             matches.append(m)
182
183         snip = text[start:end]
184         matches.sort(lambda a, b: cmp(b[0], a[0]))
185
186         for (s, e) in matches:
187             off = - start
188             snip = snip[:e + off] + mark[1] + snip[e + off:]
189             snip = snip[:s + off] + mark[0] + snip[s + off:]
190
191         return snip