Mercurial > repos > gga > chado_feature_load_featureprops
comparison chado.py @ 0:b5d8e6e26d01 draft
planemo upload for repository https://github.com/galaxy-genome-annotation/galaxy-tools/tree/master/tools/chado commit 81a83f06b49db32928ba0cd44e5b6d0431868d27
author | gga |
---|---|
date | Thu, 21 Jun 2018 08:44:44 -0400 |
parents | |
children | 402032cb55a1 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:b5d8e6e26d01 |
---|---|
1 import collections | |
2 import os | |
3 import time | |
4 from abc import abstractmethod | |
5 | |
6 import chado | |
7 | |
8 | |
9 ############################################# | |
10 # BEGIN IMPORT OF CACHING LIBRARY # | |
11 ############################################# | |
12 # This code is licensed under the MIT # | |
13 # License and is a copy of code publicly # | |
14 # available in rev. # | |
15 # e27332bc82f4e327aedaec17c9b656ae719322ed # | |
16 # of https://github.com/tkem/cachetools/ # | |
17 ############################################# | |
18 class DefaultMapping(collections.MutableMapping): | |
19 | |
20 __slots__ = () | |
21 | |
22 @abstractmethod | |
23 def __contains__(self, key): # pragma: nocover | |
24 return False | |
25 | |
26 @abstractmethod | |
27 def __getitem__(self, key): # pragma: nocover | |
28 if hasattr(self.__class__, '__missing__'): | |
29 return self.__class__.__missing__(self, key) | |
30 else: | |
31 raise KeyError(key) | |
32 | |
33 def get(self, key, default=None): | |
34 if key in self: | |
35 return self[key] | |
36 else: | |
37 return default | |
38 | |
39 __marker = object() | |
40 | |
41 def pop(self, key, default=__marker): | |
42 if key in self: | |
43 value = self[key] | |
44 del self[key] | |
45 elif default is self.__marker: | |
46 raise KeyError(key) | |
47 else: | |
48 value = default | |
49 return value | |
50 | |
51 def setdefault(self, key, default=None): | |
52 if key in self: | |
53 value = self[key] | |
54 else: | |
55 self[key] = value = default | |
56 return value | |
57 | |
58 | |
59 DefaultMapping.register(dict) | |
60 | |
61 | |
62 class _DefaultSize(object): | |
63 def __getitem__(self, _): | |
64 return 1 | |
65 | |
66 def __setitem__(self, _, value): | |
67 assert value == 1 | |
68 | |
69 def pop(self, _): | |
70 return 1 | |
71 | |
72 | |
73 class Cache(DefaultMapping): | |
74 """Mutable mapping to serve as a simple cache or cache base class.""" | |
75 | |
76 __size = _DefaultSize() | |
77 | |
78 def __init__(self, maxsize, missing=None, getsizeof=None): | |
79 if missing: | |
80 self.__missing = missing | |
81 if getsizeof: | |
82 self.__getsizeof = getsizeof | |
83 self.__size = dict() | |
84 self.__data = dict() | |
85 self.__currsize = 0 | |
86 self.__maxsize = maxsize | |
87 | |
88 def __repr__(self): | |
89 return '%s(%r, maxsize=%r, currsize=%r)' % ( | |
90 self.__class__.__name__, | |
91 list(self.__data.items()), | |
92 self.__maxsize, | |
93 self.__currsize, | |
94 ) | |
95 | |
96 def __getitem__(self, key): | |
97 try: | |
98 return self.__data[key] | |
99 except KeyError: | |
100 return self.__missing__(key) | |
101 | |
102 def __setitem__(self, key, value): | |
103 maxsize = self.__maxsize | |
104 size = self.getsizeof(value) | |
105 if size > maxsize: | |
106 raise ValueError('value too large') | |
107 if key not in self.__data or self.__size[key] < size: | |
108 while self.__currsize + size > maxsize: | |
109 self.popitem() | |
110 if key in self.__data: | |
111 diffsize = size - self.__size[key] | |
112 else: | |
113 diffsize = size | |
114 self.__data[key] = value | |
115 self.__size[key] = size | |
116 self.__currsize += diffsize | |
117 | |
118 def __delitem__(self, key): | |
119 size = self.__size.pop(key) | |
120 del self.__data[key] | |
121 self.__currsize -= size | |
122 | |
123 def __contains__(self, key): | |
124 return key in self.__data | |
125 | |
126 def __missing__(self, key): | |
127 value = self.__missing(key) | |
128 try: | |
129 self.__setitem__(key, value) | |
130 except ValueError: | |
131 pass # value too large | |
132 return value | |
133 | |
134 def __iter__(self): | |
135 return iter(self.__data) | |
136 | |
137 def __len__(self): | |
138 return len(self.__data) | |
139 | |
140 @staticmethod | |
141 def __getsizeof(value): | |
142 return 1 | |
143 | |
144 @staticmethod | |
145 def __missing(key): | |
146 raise KeyError(key) | |
147 | |
148 @property | |
149 def maxsize(self): | |
150 """The maximum size of the cache.""" | |
151 return self.__maxsize | |
152 | |
153 @property | |
154 def currsize(self): | |
155 """The current size of the cache.""" | |
156 return self.__currsize | |
157 | |
158 def getsizeof(self, value): | |
159 """Return the size of a cache element's value.""" | |
160 return self.__getsizeof(value) | |
161 | |
162 | |
163 class _Link(object): | |
164 | |
165 __slots__ = ('key', 'expire', 'next', 'prev') | |
166 | |
167 def __init__(self, key=None, expire=None): | |
168 self.key = key | |
169 self.expire = expire | |
170 | |
171 def __reduce__(self): | |
172 return _Link, (self.key, self.expire) | |
173 | |
174 def unlink(self): | |
175 next = self.next | |
176 prev = self.prev | |
177 prev.next = next | |
178 next.prev = prev | |
179 | |
180 | |
181 class _Timer(object): | |
182 | |
183 def __init__(self, timer): | |
184 self.__timer = timer | |
185 self.__nesting = 0 | |
186 | |
187 def __call__(self): | |
188 if self.__nesting == 0: | |
189 return self.__timer() | |
190 else: | |
191 return self.__time | |
192 | |
193 def __enter__(self): | |
194 if self.__nesting == 0: | |
195 self.__time = time = self.__timer() | |
196 else: | |
197 time = self.__time | |
198 self.__nesting += 1 | |
199 return time | |
200 | |
201 def __exit__(self, *exc): | |
202 self.__nesting -= 1 | |
203 | |
204 def __reduce__(self): | |
205 return _Timer, (self.__timer,) | |
206 | |
207 def __getattr__(self, name): | |
208 return getattr(self.__timer, name) | |
209 | |
210 | |
211 class TTLCache(Cache): | |
212 """LRU Cache implementation with per-item time-to-live (TTL) value.""" | |
213 | |
214 def __init__(self, maxsize, ttl, timer=time.time, missing=None, | |
215 getsizeof=None): | |
216 Cache.__init__(self, maxsize, missing, getsizeof) | |
217 self.__root = root = _Link() | |
218 root.prev = root.next = root | |
219 self.__links = collections.OrderedDict() | |
220 self.__timer = _Timer(timer) | |
221 self.__ttl = ttl | |
222 | |
223 def __contains__(self, key): | |
224 try: | |
225 link = self.__links[key] # no reordering | |
226 except KeyError: | |
227 return False | |
228 else: | |
229 return not (link.expire < self.__timer()) | |
230 | |
231 def __getitem__(self, key, cache_getitem=Cache.__getitem__): | |
232 try: | |
233 link = self.__getlink(key) | |
234 except KeyError: | |
235 expired = False | |
236 else: | |
237 expired = link.expire < self.__timer() | |
238 if expired: | |
239 return self.__missing__(key) | |
240 else: | |
241 return cache_getitem(self, key) | |
242 | |
243 def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): | |
244 with self.__timer as time: | |
245 self.expire(time) | |
246 cache_setitem(self, key, value) | |
247 try: | |
248 link = self.__getlink(key) | |
249 except KeyError: | |
250 self.__links[key] = link = _Link(key) | |
251 else: | |
252 link.unlink() | |
253 link.expire = time + self.__ttl | |
254 link.next = root = self.__root | |
255 link.prev = prev = root.prev | |
256 prev.next = root.prev = link | |
257 | |
258 def __delitem__(self, key, cache_delitem=Cache.__delitem__): | |
259 cache_delitem(self, key) | |
260 link = self.__links.pop(key) | |
261 link.unlink() | |
262 if link.expire < self.__timer(): | |
263 raise KeyError(key) | |
264 | |
265 def __iter__(self): | |
266 root = self.__root | |
267 curr = root.next | |
268 while curr is not root: | |
269 # "freeze" time for iterator access | |
270 with self.__timer as time: | |
271 if not (curr.expire < time): | |
272 yield curr.key | |
273 curr = curr.next | |
274 | |
275 def __len__(self): | |
276 root = self.__root | |
277 curr = root.next | |
278 time = self.__timer() | |
279 count = len(self.__links) | |
280 while curr is not root and curr.expire < time: | |
281 count -= 1 | |
282 curr = curr.next | |
283 return count | |
284 | |
285 def __setstate__(self, state): | |
286 self.__dict__.update(state) | |
287 root = self.__root | |
288 root.prev = root.next = root | |
289 for link in sorted(self.__links.values(), key=lambda obj: obj.expire): | |
290 link.next = root | |
291 link.prev = prev = root.prev | |
292 prev.next = root.prev = link | |
293 self.expire(self.__timer()) | |
294 | |
295 def __repr__(self, cache_repr=Cache.__repr__): | |
296 with self.__timer as time: | |
297 self.expire(time) | |
298 return cache_repr(self) | |
299 | |
300 @property | |
301 def currsize(self): | |
302 with self.__timer as time: | |
303 self.expire(time) | |
304 return super(TTLCache, self).currsize | |
305 | |
306 @property | |
307 def timer(self): | |
308 """The timer function used by the cache.""" | |
309 return self.__timer | |
310 | |
311 @property | |
312 def ttl(self): | |
313 """The time-to-live value of the cache's items.""" | |
314 return self.__ttl | |
315 | |
316 def expire(self, time=None): | |
317 """Remove expired items from the cache.""" | |
318 if time is None: | |
319 time = self.__timer() | |
320 root = self.__root | |
321 curr = root.next | |
322 links = self.__links | |
323 cache_delitem = Cache.__delitem__ | |
324 while curr is not root and curr.expire < time: | |
325 cache_delitem(self, curr.key) | |
326 del links[curr.key] | |
327 next = curr.next | |
328 curr.unlink() | |
329 curr = next | |
330 | |
331 def clear(self): | |
332 with self.__timer as time: | |
333 self.expire(time) | |
334 Cache.clear(self) | |
335 | |
336 def get(self, *args, **kwargs): | |
337 with self.__timer: | |
338 return Cache.get(self, *args, **kwargs) | |
339 | |
340 def pop(self, *args, **kwargs): | |
341 with self.__timer: | |
342 return Cache.pop(self, *args, **kwargs) | |
343 | |
344 def setdefault(self, *args, **kwargs): | |
345 with self.__timer: | |
346 return Cache.setdefault(self, *args, **kwargs) | |
347 | |
348 def popitem(self): | |
349 """Remove and return the `(key, value)` pair least recently used that | |
350 has not already expired. | |
351 | |
352 """ | |
353 with self.__timer as time: | |
354 self.expire(time) | |
355 try: | |
356 key = next(iter(self.__links)) | |
357 except StopIteration: | |
358 raise KeyError('%s is empty' % self.__class__.__name__) | |
359 else: | |
360 return (key, self.pop(key)) | |
361 | |
362 if hasattr(collections.OrderedDict, 'move_to_end'): | |
363 def __getlink(self, key): | |
364 value = self.__links[key] | |
365 self.__links.move_to_end(key) | |
366 return value | |
367 else: | |
368 def __getlink(self, key): | |
369 value = self.__links.pop(key) | |
370 self.__links[key] = value | |
371 return value | |
372 | |
373 | |
374 ############################################# | |
375 # END IMPORT OF CACHING LIBRARY # | |
376 ############################################# | |
377 | |
378 cache = TTLCache( | |
379 100, # Up to 100 items | |
380 1 * 60 # 5 minute cache life | |
381 ) | |
382 | |
383 | |
384 def _get_instance(): | |
385 return chado.ChadoInstance( | |
386 os.environ['GALAXY_CHADO_DBHOST'], | |
387 os.environ['GALAXY_CHADO_DBNAME'], | |
388 os.environ['GALAXY_CHADO_DBUSER'], | |
389 os.environ['GALAXY_CHADO_DBPASS'], | |
390 os.environ['GALAXY_CHADO_DBSCHEMA'], | |
391 os.environ['GALAXY_CHADO_DBPORT'], | |
392 no_reflect=True | |
393 ) | |
394 | |
395 | |
396 def list_organisms(*args, **kwargs): | |
397 | |
398 ci = _get_instance() | |
399 | |
400 # Key for cached data | |
401 cacheKey = 'orgs' | |
402 # We don't want to trust "if key in cache" because between asking and fetch | |
403 # it might through key error. | |
404 if cacheKey not in cache: | |
405 # However if it ISN'T there, we know we're safe to fetch + put in | |
406 # there. | |
407 data = _list_organisms(ci, *args, **kwargs) | |
408 cache[cacheKey] = data | |
409 return data | |
410 try: | |
411 # The cache key may or may not be in the cache at this point, it | |
412 # /likely/ is. However we take no chances that it wasn't evicted between | |
413 # when we checked above and now, so we reference the object from the | |
414 # cache in preparation to return. | |
415 data = cache[cacheKey] | |
416 return data | |
417 except KeyError: | |
418 # If access fails due to eviction, we will fail over and can ensure that | |
419 # data is inserted. | |
420 data = _list_organisms(ci, *args, **kwargs) | |
421 cache[cacheKey] = data | |
422 return data | |
423 | |
424 | |
425 def _list_organisms(ci, *args, **kwargs): | |
426 # Fetch the orgs. | |
427 orgs_data = [] | |
428 for org in ci.organism.get_organisms(): | |
429 clean_name = '%s %s' % (org['genus'], org['species']) | |
430 if 'infraspecific_name' in org and org['infraspecific_name']: | |
431 clean_name += ' (%s)' % (org['infraspecific_name']) | |
432 orgs_data.append((clean_name, str(org['organism_id']), False)) | |
433 return orgs_data | |
434 | |
435 | |
436 def list_analyses(*args, **kwargs): | |
437 | |
438 ci = _get_instance() | |
439 | |
440 # Key for cached data | |
441 cacheKey = 'analyses' | |
442 # We don't want to trust "if key in cache" because between asking and fetch | |
443 # it might through key error. | |
444 if cacheKey not in cache: | |
445 # However if it ISN'T there, we know we're safe to fetch + put in | |
446 # there.<?xml version="1.0"?> | |
447 | |
448 data = _list_analyses(ci, *args, **kwargs) | |
449 cache[cacheKey] = data | |
450 return data | |
451 try: | |
452 # The cache key may or may not be in the cache at this point, it | |
453 # /likely/ is. However we take no chances that it wasn't evicted between | |
454 # when we checked above and now, so we reference the object from the | |
455 # cache in preparation to return. | |
456 data = cache[cacheKey] | |
457 return data | |
458 except KeyError: | |
459 # If access fails due to eviction, we will fail over and can ensure that | |
460 # data is inserted. | |
461 data = _list_analyses(ci, *args, **kwargs) | |
462 cache[cacheKey] = data | |
463 return data | |
464 | |
465 | |
466 def _list_analyses(ci, *args, **kwargs): | |
467 ans_data = [] | |
468 for an in ci.analysis.get_analyses(): | |
469 ans_data.append((an['name'], str(an['analysis_id']), False)) | |
470 return ans_data |