Fixing bunches of issues with the presenter
[watersofshiloah] / src / stream_index.py
1 import weakref
2 import logging
3
4 import util.misc as misc_utils
5 from util import go_utils
6 import backend
7
8
9 _moduleLogger = logging.getLogger(__name__)
10
11
12 SOURCE_RADIO = "radio"
13 SOURCE_CONFERENCES = "conferences"
14 SOURCE_MAGAZINES = "magazines"
15 SOURCE_SCRIPTURES = "scriptures"
16
17
18 class Connection(object):
19
20         def __init__(self):
21                 self._backend = backend.Backend()
22                 self._indexing = go_utils.AsyncPool()
23
24         def start(self):
25                 self._indexing.start()
26
27         def stop(self):
28                 self._indexing.stop()
29
30         def download(self, func, on_success, on_error, args = None, kwds = None):
31                 if args is None:
32                         args = ()
33                 if kwds is None:
34                         kwds = {}
35
36                 self._indexing.clear_tasks()
37                 self._indexing.add_task(
38                         getattr(self._backend, func),
39                         args,
40                         kwds,
41                         on_success,
42                         on_error,
43                 )
44
45
46 class AudioIndex(object):
47
48         def __init__(self):
49                 self._connection = Connection()
50                 self._languages = None
51                 self._languagesRequest = None
52                 self._sources = {}
53
54         def start(self):
55                 self._connection.start()
56
57         def stop(self):
58                 self._connection.stop()
59
60         def get_languages(self, on_success, on_error):
61                 if self._languages is None:
62                         assert self._languagesRequest is None
63                         self._languagesRequest = on_success, on_error
64                         self._connection.download(
65                                 "get_languages",
66                                 self._on_get_languages,
67                                 self._on_languages_error
68                         )
69                 else:
70                         on_success(self._languages)
71
72         def get_source(self, source, langId = None):
73                 key = (source, langId)
74                 if key in self._sources:
75                         node = self._sources[key]
76                 else:
77                         if source == SOURCE_RADIO:
78                                 node = RadioNode(self._connection)
79                         elif source == SOURCE_CONFERENCES:
80                                 assert langId is not None
81                                 node = ConferencesNode(self._connection, langId)
82                         else:
83                                 raise NotImplementedError(source)
84                         self._sources[key] = node
85
86                 return node
87
88         @misc_utils.log_exception(_moduleLogger)
89         def _on_get_languages(self, languages):
90                 assert self._languages is None
91                 assert self._languagesRequest is not None
92                 r = self._languagesRequest
93                 self._languagesRequest = None
94                 self._languages = languages
95                 r[0](self._languages)
96
97         @misc_utils.log_exception(_moduleLogger)
98         def _on_languages_error(self, e):
99                 assert self._languages is None
100                 assert self._languagesRequest is not None
101                 r = self._languagesRequest
102                 self._languagesRequest = None
103                 r[1](self._languages)
104
105
106 class Node(object):
107
108         def __init__(self, connection, parent, data, id):
109                 self._connection = connection
110                 self._parent = weakref.ref(parent) if parent is not None else None
111                 self._data = data
112                 self._children = None
113                 self._id = id
114
115         def get_children(self, on_success, on_error):
116                 if self._children is None:
117                         self._get_children(on_success, on_error)
118                 else:
119                         on_success(self._children)
120
121         def get_parent(self):
122                 if self._parent is None:
123                         raise RuntimeError("")
124                 parent = self._parent()
125                 return parent
126
127         def get_properties(self):
128                 return self._data
129
130         @property
131         def title(self):
132                 raise NotImplementedError("On %s" % type(self))
133
134         @property
135         def id(self):
136                 return self._id
137
138         def is_leaf(self):
139                 raise NotImplementedError("")
140
141         def _get_children(self, on_success, on_error):
142                 raise NotImplementedError("")
143
144
145 class ParentNode(Node):
146
147         def __init__(self, connection, parent, data, id):
148                 Node.__init__(self, connection, parent, data, id)
149                 self._request = None
150
151         def is_leaf(self):
152                 return False
153
154         def _get_children(self, on_success, on_error):
155                 assert self._request is None
156                 assert self._children is None
157                 self._request = on_success, on_error
158
159                 func, args, kwds = self._get_func()
160
161                 self._connection.download(
162                         func,
163                         self._on_success,
164                         self._on_error,
165                         args,
166                         kwds,
167                 )
168
169         def _get_func(self):
170                 raise NotImplementedError()
171
172         def _create_child(self, data, id):
173                 raise NotImplementedError()
174
175         @misc_utils.log_exception(_moduleLogger)
176         def _on_success(self, data):
177                 r = self._request
178                 self._request = None
179                 try:
180                         self._children = [
181                                 self._create_child(child, i)
182                                 for i, child in enumerate(data)
183                         ]
184                 except Exception, e:
185                         _moduleLogger.exception("Translating error")
186                         self._children = None
187                         r[1](e)
188                 else:
189                         r[0](self._children)
190
191         @misc_utils.log_exception(_moduleLogger)
192         def _on_error(self, error):
193                 r = self._request
194                 self._request = None
195                 r[1](error)
196
197
198 class LeafNode(Node):
199
200         def __init__(self, connection, parent, data, id):
201                 Node.__init__(self, connection, parent, data, id)
202
203         def is_leaf(self):
204                 return True
205
206         @property
207         def can_navigate(self):
208                 raise NotImplementedError("On %s" % type(self))
209
210         @property
211         def subtitle(self):
212                 raise NotImplementedError("On %s" % type(self))
213
214         @property
215         def uri(self):
216                 raise NotImplementedError("On %s" % type(self))
217
218         def _get_children(self, on_success, on_error):
219                 raise RuntimeError("Not is a leaf")
220
221
222 class RadioNode(ParentNode):
223
224         def __init__(self, connection):
225                 ParentNode.__init__(self, connection, None, {}, SOURCE_RADIO)
226
227         @property
228         def title(self):
229                 return "Radio"
230
231         def _get_func(self):
232                 return "get_radio_channels", (), {}
233
234         def _create_child(self, data, id):
235                 return RadioChannelNode(self._connection, self, data, id)
236
237
238 class RadioChannelNode(LeafNode):
239
240         def __init__(self, connection, parent, data, id):
241                 LeafNode.__init__(self, connection, parent, data, id)
242                 self._extendedData = {}
243                 self._request = None
244
245         @property
246         def can_navigate(self):
247                 return False
248
249         @property
250         def title(self):
251                 return "Radio"
252
253         @property
254         def subtitle(self):
255                 return ""
256
257         @property
258         def uri(self):
259                 return self._data["url"]
260
261         def get_programming(self, date, on_success, on_error):
262                 date = date.strftime("%Y-%m-%d")
263                 try:
264                         programming = self._extendedData[date]
265                 except KeyError:
266                         self._get_programming(date, on_success, on_error)
267                 else:
268                         on_success(programming)
269
270         def _get_programming(self, date, on_success, on_error):
271                 assert self._request is None
272                 assert date not in self._extendedData
273                 self._request = on_success, on_error, date
274
275                 self._connection.download(
276                         "get_radio_channel_programming",
277                         self._on_success,
278                         self._on_error,
279                         (self._data["id"], date),
280                         {},
281                 )
282
283         @misc_utils.log_exception(_moduleLogger)
284         def _on_success(self, data):
285                 r = self._request
286                 date = r[2]
287                 self._request = None
288                 try:
289                         self._extendedData[date] = [
290                                 child
291                                 for child in data
292                         ]
293                 except Exception, e:
294                         _moduleLogger.exception("Translating error")
295                         del self._extendedData[date]
296                         r[1](e)
297                 else:
298                         r[0](self._extendedData[date])
299
300         @misc_utils.log_exception(_moduleLogger)
301         def _on_error(self, error):
302                 r = self._request
303                 self._request = None
304                 r[1](error)
305
306
307 class ConferencesNode(ParentNode):
308
309         def __init__(self, connection, langId):
310                 ParentNode.__init__(self, connection, None, {}, SOURCE_CONFERENCES)
311                 self._langId = langId
312
313         @property
314         def title(self):
315                 return "Conferences"
316
317         def _get_func(self):
318                 return "get_conferences", (self._langId, ), {}
319
320         def _create_child(self, data, id):
321                 return ConferenceNode(self._connection, self, data, id)
322
323
324 class ConferenceNode(ParentNode):
325
326         def __init__(self, connection, parent, data, id):
327                 ParentNode.__init__(self, connection, parent, data, id)
328
329         @property
330         def title(self):
331                 return self._data["title"]
332
333         def _get_func(self):
334                 return "get_conference_sessions", (self._data["id"], ), {}
335
336         def _create_child(self, data, id):
337                 return SessionNode(self._connection, self, data, id)
338
339
340 class SessionNode(ParentNode):
341
342         def __init__(self, connection, parent, data, id):
343                 ParentNode.__init__(self, connection, parent, data, id)
344
345         @property
346         def title(self):
347                 return self._data["title"]
348
349         def _get_func(self):
350                 return "get_conference_talks", (self._data["id"], ), {}
351
352         def _create_child(self, data, id):
353                 return TalkNode(self._connection, self, data, id)
354
355
356 class TalkNode(LeafNode):
357
358         def __init__(self, connection, parent, data, id):
359                 LeafNode.__init__(self, connection, parent, data, id)
360
361         @property
362         def can_navigate(self):
363                 return True
364
365         @property
366         def title(self):
367                 return self._data["title"]
368
369         @property
370         def subtitle(self):
371                 speaker = self._data["speaker"]
372                 if speaker is not None:
373                         return speaker
374                 else:
375                         return ""
376
377         @property
378         def uri(self):
379                 return self._data["url"]
380
381
382 def walk_ancestors(node):
383         while True:
384                 yield node
385                 try:
386                         node = node.get_parent()
387                 except RuntimeError:
388                         return
389
390
391 def common_paths(targetNode, currentNode):
392         targetNodePath = list(walk_ancestors(targetNode))
393         targetNodePath.reverse()
394         currentNodePath = list(walk_ancestors(currentNode))
395         currentNodePath.reverse()
396
397         ancestors = []
398         descendants = []
399
400         for i, (t, c) in enumerate(zip(targetNodePath, currentNodePath)):
401                 if t is not c:
402                         return ancestors, None, descendants
403                 ancestors.append(t)
404
405         descendants.extend(
406                 child
407                 for child in targetNodePath[i+1:]
408         )
409
410         return ancestors, currentNode, descendants