Mercurial > repos > gga > apollo_export

comparison webapollo.py @ 0:b4a85d0c85b8 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload for repository https://github.com/galaxy-genome-annotation/galaxy-tools/tree/master/tools/apollo commit f745b23c84a615bf434d717c8c0e553a012f0268
author gga
date Mon, 11 Sep 2017 05:47:07 -0400
parents
children d1d6d9fdbfbd
comparison
equal deleted inserted replaced
-1:000000000000 0:b4a85d0c85b8
1 from __future__ import print_function
2
3 import argparse
4 import collections
5 import json
6 import logging
7 import os
8 import time
9
10 from abc import abstractmethod
11 from builtins import next
12 from builtins import object
13 from builtins import str
14
15 from BCBio import GFF
16
17 from Bio import SeqIO
18
19 from future import standard_library
20
21 import requests
22
23
24 standard_library.install_aliases()
25 try:
26 import StringIO as io
27 except BaseException:
28 import io
29 logging.getLogger("requests").setLevel(logging.CRITICAL)
30 log = logging.getLogger()
31
32
33 #############################################
34 # BEGIN IMPORT OF CACHING LIBRARY #
35 #############################################
36 # This code is licensed under the MIT #
37 # License and is a copy of code publicly #
38 # available in rev. #
39 # e27332bc82f4e327aedaec17c9b656ae719322ed #
40 # of https://github.com/tkem/cachetools/ #
41 #############################################
42
43 class DefaultMapping(collections.MutableMapping):
44
45 __slots__ = ()
46
47 @abstractmethod
48 def __contains__(self, key): # pragma: nocover
49 return False
50
51 @abstractmethod
52 def __getitem__(self, key): # pragma: nocover
53 if hasattr(self.__class__, '__missing__'):
54 return self.__class__.__missing__(self, key)
55 else:
56 raise KeyError(key)
57
58 def get(self, key, default=None):
59 if key in self:
60 return self[key]
61 else:
62 return default
63
64 __marker = object()
65
66 def pop(self, key, default=__marker):
67 if key in self:
68 value = self[key]
69 del self[key]
70 elif default is self.__marker:
71 raise KeyError(key)
72 else:
73 value = default
74 return value
75
76 def setdefault(self, key, default=None):
77 if key in self:
78 value = self[key]
79 else:
80 self[key] = value = default
81 return value
82
83
84 DefaultMapping.register(dict)
85
86
87 class _DefaultSize(object):
88 def __getitem__(self, _):
89 return 1
90
91 def __setitem__(self, _, value):
92 assert value == 1
93
94 def pop(self, _):
95 return 1
96
97
98 class Cache(DefaultMapping):
99 """Mutable mapping to serve as a simple cache or cache base class."""
100
101 __size = _DefaultSize()
102
103 def __init__(self, maxsize, missing=None, getsizeof=None):
104 if missing:
105 self.__missing = missing
106 if getsizeof:
107 self.__getsizeof = getsizeof
108 self.__size = dict()
109 self.__data = dict()
110 self.__currsize = 0
111 self.__maxsize = maxsize
112
113 def __repr__(self):
114 return '%s(%r, maxsize=%r, currsize=%r)' % (
115 self.__class__.__name__,
116 list(self.__data.items()),
117 self.__maxsize,
118 self.__currsize,
119 )
120
121 def __getitem__(self, key):
122 try:
123 return self.__data[key]
124 except KeyError:
125 return self.__missing__(key)
126
127 def __setitem__(self, key, value):
128 maxsize = self.__maxsize
129 size = self.getsizeof(value)
130 if size > maxsize:
131 raise ValueError('value too large')
132 if key not in self.__data or self.__size[key] < size:
133 while self.__currsize + size > maxsize:
134 self.popitem()
135 if key in self.__data:
136 diffsize = size - self.__size[key]
137 else:
138 diffsize = size
139 self.__data[key] = value
140 self.__size[key] = size
141 self.__currsize += diffsize
142
143 def __delitem__(self, key):
144 size = self.__size.pop(key)
145 del self.__data[key]
146 self.__currsize -= size
147
148 def __contains__(self, key):
149 return key in self.__data
150
151 def __missing__(self, key):
152 value = self.__missing(key)
153 try:
154 self.__setitem__(key, value)
155 except ValueError:
156 pass # value too large
157 return value
158
159 def __iter__(self):
160 return iter(self.__data)
161
162 def __len__(self):
163 return len(self.__data)
164
165 @staticmethod
166 def __getsizeof(value):
167 return 1
168
169 @staticmethod
170 def __missing(key):
171 raise KeyError(key)
172
173 @property
174 def maxsize(self):
175 """The maximum size of the cache."""
176 return self.__maxsize
177
178 @property
179 def currsize(self):
180 """The current size of the cache."""
181 return self.__currsize
182
183 def getsizeof(self, value):
184 """Return the size of a cache element's value."""
185 return self.__getsizeof(value)
186
187
188 class _Link(object):
189
190 __slots__ = ('key', 'expire', 'next', 'prev')
191
192 def __init__(self, key=None, expire=None):
193 self.key = key
194 self.expire = expire
195
196 def __reduce__(self):
197 return _Link, (self.key, self.expire)
198
199 def unlink(self):
200 next = self.next
201 prev = self.prev
202 prev.next = next
203 next.prev = prev
204
205
206 class _Timer(object):
207
208 def __init__(self, timer):
209 self.__timer = timer
210 self.__nesting = 0
211
212 def __call__(self):
213 if self.__nesting == 0:
214 return self.__timer()
215 else:
216 return self.__time
217
218 def __enter__(self):
219 if self.__nesting == 0:
220 self.__time = time = self.__timer()
221 else:
222 time = self.__time
223 self.__nesting += 1
224 return time
225
226 def __exit__(self, *exc):
227 self.__nesting -= 1
228
229 def __reduce__(self):
230 return _Timer, (self.__timer,)
231
232 def __getattr__(self, name):
233 return getattr(self.__timer, name)
234
235
236 class TTLCache(Cache):
237 """LRU Cache implementation with per-item time-to-live (TTL) value."""
238
239 def __init__(self, maxsize, ttl, timer=time.time, missing=None,
240 getsizeof=None):
241 Cache.__init__(self, maxsize, missing, getsizeof)
242 self.__root = root = _Link()
243 root.prev = root.next = root
244 self.__links = collections.OrderedDict()
245 self.__timer = _Timer(timer)
246 self.__ttl = ttl
247
248 def __contains__(self, key):
249 try:
250 link = self.__links[key] # no reordering
251 except KeyError:
252 return False
253 else:
254 return not (link.expire < self.__timer())
255
256 def __getitem__(self, key, cache_getitem=Cache.__getitem__):
257 try:
258 link = self.__getlink(key)
259 except KeyError:
260 expired = False
261 else:
262 expired = link.expire < self.__timer()
263 if expired:
264 return self.__missing__(key)
265 else:
266 return cache_getitem(self, key)
267
268 def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
269 with self.__timer as time:
270 self.expire(time)
271 cache_setitem(self, key, value)
272 try:
273 link = self.__getlink(key)
274 except KeyError:
275 self.__links[key] = link = _Link(key)
276 else:
277 link.unlink()
278 link.expire = time + self.__ttl
279 link.next = root = self.__root
280 link.prev = prev = root.prev
281 prev.next = root.prev = link
282
283 def __delitem__(self, key, cache_delitem=Cache.__delitem__):
284 cache_delitem(self, key)
285 link = self.__links.pop(key)
286 link.unlink()
287 if link.expire < self.__timer():
288 raise KeyError(key)
289
290 def __iter__(self):
291 root = self.__root
292 curr = root.next
293 while curr is not root:
294 # "freeze" time for iterator access
295 with self.__timer as time:
296 if not (curr.expire < time):
297 yield curr.key
298 curr = curr.next
299
300 def __len__(self):
301 root = self.__root
302 curr = root.next
303 time = self.__timer()
304 count = len(self.__links)
305 while curr is not root and curr.expire < time:
306 count -= 1
307 curr = curr.next
308 return count
309
310 def __setstate__(self, state):
311 self.__dict__.update(state)
312 root = self.__root
313 root.prev = root.next = root
314 for link in sorted(self.__links.values(), key=lambda obj: obj.expire):
315 link.next = root
316 link.prev = prev = root.prev
317 prev.next = root.prev = link
318 self.expire(self.__timer())
319
320 def __repr__(self, cache_repr=Cache.__repr__):
321 with self.__timer as time:
322 self.expire(time)
323 return cache_repr(self)
324
325 @property
326 def currsize(self):
327 with self.__timer as time:
328 self.expire(time)
329 return super(TTLCache, self).currsize
330
331 @property
332 def timer(self):
333 """The timer function used by the cache."""
334 return self.__timer
335
336 @property
337 def ttl(self):
338 """The time-to-live value of the cache's items."""
339 return self.__ttl
340
341 def expire(self, time=None):
342 """Remove expired items from the cache."""
343 if time is None:
344 time = self.__timer()
345 root = self.__root
346 curr = root.next
347 links = self.__links
348 cache_delitem = Cache.__delitem__
349 while curr is not root and curr.expire < time:
350 cache_delitem(self, curr.key)
351 del links[curr.key]
352 next = curr.next
353 curr.unlink()
354 curr = next
355
356 def clear(self):
357 with self.__timer as time:
358 self.expire(time)
359 Cache.clear(self)
360
361 def get(self, *args, **kwargs):
362 with self.__timer:
363 return Cache.get(self, *args, **kwargs)
364
365 def pop(self, *args, **kwargs):
366 with self.__timer:
367 return Cache.pop(self, *args, **kwargs)
368
369 def setdefault(self, *args, **kwargs):
370 with self.__timer:
371 return Cache.setdefault(self, *args, **kwargs)
372
373 def popitem(self):
374 """Remove and return the `(key, value)` pair least recently used that
375 has not already expired.
376
377 """
378 with self.__timer as time:
379 self.expire(time)
380 try:
381 key = next(iter(self.__links))
382 except StopIteration:
383 raise KeyError('%s is empty' % self.__class__.__name__)
384 else:
385 return (key, self.pop(key))
386
387 if hasattr(collections.OrderedDict, 'move_to_end'):
388 def __getlink(self, key):
389 value = self.__links[key]
390 self.__links.move_to_end(key)
391 return value
392 else:
393 def __getlink(self, key):
394 value = self.__links.pop(key)
395 self.__links[key] = value
396 return value
397
398
399 #############################################
400 # END IMPORT OF CACHING LIBRARY #
401 #############################################
402
403
404 cache = TTLCache(
405 100, # Up to 100 items
406 5 * 60 # 5 minute cache life
407 )
408 userCache = TTLCache(
409 2, # Up to 2 items
410 60 # 1 minute cache life
411 )
412
413
414 class UnknownUserException(Exception):
415 pass
416
417
418 def WAAuth(parser):
419 parser.add_argument('apollo', help='Complete Apollo URL')
420 parser.add_argument('username', help='WA Username')
421 parser.add_argument('password', help='WA Password')
422
423
424 def OrgOrGuess(parser):
425 parser.add_argument('--org_json', type=argparse.FileType("r"), help='Apollo JSON output, source for common name')
426 parser.add_argument('--org_raw', help='Common Name')
427 parser.add_argument('--org_id', help='Organism ID')
428
429
430 def CnOrGuess(parser):
431 OrgOrGuess(parser)
432 parser.add_argument('--seq_fasta', type=argparse.FileType("r"), help='Fasta file, IDs used as sequence sources')
433 parser.add_argument('--seq_raw', nargs='*', help='Sequence Names')
434
435
436 def GuessOrg(args, wa):
437 if args.org_json:
438 orgs = [x.get('commonName', None)
439 for x in json.load(args.org_json)]
440 orgs = [x for x in orgs if x is not None]
441 return orgs
442 elif args.org_raw:
443 org = args.org_raw.strip()
444 if len(org) > 0:
445 return [org]
446 else:
447 raise Exception("Organism Common Name not provided")
448 elif args.org_id:
449 return [wa.organisms.findOrganismById(args.org_id).get('commonName', None)]
450 else:
451 raise Exception("Organism Common Name not provided")
452
453
454 def GuessCn(args, wa):
455 org = GuessOrg(args, wa)
456 seqs = []
457 if args.seq_fasta:
458 # If we have a fasta, pull all rec ids from that.
459 for rec in SeqIO.parse(args.seq_fasta, 'fasta'):
460 seqs.append(rec.id)
461 elif args.seq_raw:
462 # Otherwise raw list.
463 seqs = [x.strip() for x in args.seq_raw if len(x.strip()) > 0]
464
465 return org, seqs
466
467
468 def AssertUser(user_list):
469 if len(user_list) == 0:
470 raise UnknownUserException()
471 elif len(user_list) == 1:
472 return user_list[0]
473 else:
474 raise Exception("Too many users!")
475
476
477 def AssertAdmin(user):
478 if user.role == 'ADMIN':
479 return True
480 else:
481 raise Exception("User is not an administrator. Permission denied")
482
483
484 class WebApolloInstance(object):
485
486 def __init__(self, url, username, password):
487 self.apollo_url = url
488 self.username = username
489 self.password = password
490
491 self.annotations = AnnotationsClient(self)
492 self.groups = GroupsClient(self)
493 self.io = IOClient(self)
494 self.organisms = OrganismsClient(self)
495 self.users = UsersClient(self)
496 self.metrics = MetricsClient(self)
497 self.bio = RemoteRecord(self)
498 self.status = StatusClient(self)
499 self.canned_comments = CannedCommentsClient(self)
500 self.canned_keys = CannedKeysClient(self)
501 self.canned_values = CannedValuesClient(self)
502
503 def __str__(self):
504 return '<WebApolloInstance at %s>' % self.apollo_url
505
506 def requireUser(self, email):
507 cacheKey = 'user-list'
508 try:
509 # Get the cached value
510 data = userCache[cacheKey]
511 except KeyError:
512 # If we hit a key error above, indicating that
513 # we couldn't find the key, we'll simply re-request
514 # the data
515 data = self.users.loadUsers()
516 userCache[cacheKey] = data
517
518 return AssertUser([x for x in data if x.username == email])
519
520
521 class GroupObj(object):
522 def __init__(self, **kwargs):
523 self.name = kwargs['name']
524
525 if 'id' in kwargs:
526 self.groupId = kwargs['id']
527
528
529 class UserObj(object):
530 ROLE_USER = 'USER'
531 ROLE_ADMIN = 'ADMIN'
532
533 def __init__(self, **kwargs):
534 # Generally expect 'userId', 'firstName', 'lastName', 'username' (email)
535 for attr in kwargs.keys():
536 setattr(self, attr, kwargs[attr])
537
538 if 'groups' in kwargs:
539 groups = []
540 for groupData in kwargs['groups']:
541 groups.append(GroupObj(**groupData))
542 self.groups = groups
543
544 self.__props = kwargs.keys()
545
546 def isAdmin(self):
547 if hasattr(self, 'role'):
548 return self.role == self.ROLE_ADMIN
549 return False
550
551 def refresh(self, wa):
552 # This method requires some sleeping usually.
553 newU = wa.users.loadUser(self).toDict()
554 for prop in newU:
555 setattr(self, prop, newU[prop])
556
557 def toDict(self):
558 data = {}
559 for prop in self.__props:
560 data[prop] = getattr(self, prop)
561 return data
562
563 def orgPerms(self):
564 for orgPer in self.organismPermissions:
565 if len(orgPer['permissions']) > 2:
566 orgPer['permissions'] = json.loads(orgPer['permissions'])
567 yield orgPer
568
569 def __str__(self):
570 return '<User %s: %s %s <%s>>' % (self.userId, self.firstName,
571 self.lastName, self.username)
572
573
574 class Client(object):
575
576 def __init__(self, webapolloinstance, **requestArgs):
577 self._wa = webapolloinstance
578
579 self.__verify = requestArgs.get('verify', True)
580 self._requestArgs = requestArgs
581
582 if 'verify' in self._requestArgs:
583 del self._requestArgs['verify']
584
585 def request(self, clientMethod, data, post_params={}, isJson=True):
586 url = self._wa.apollo_url + self.CLIENT_BASE + clientMethod
587
588 headers = {
589 'Content-Type': 'application/json'
590 }
591
592 data.update({
593 'username': self._wa.username,
594 'password': self._wa.password,
595 })
596
597 r = requests.post(url, data=json.dumps(data), headers=headers,
598 verify=self.__verify, params=post_params, allow_redirects=False, **self._requestArgs)
599
600 if r.status_code == 200 or r.status_code == 302:
601 if isJson:
602 d = r.json()
603 if 'username' in d:
604 del d['username']
605 if 'password' in d:
606 del d['password']
607 return d
608 else:
609 return r.text
610
611 # @see self.body for HTTP response body
612 raise Exception("Unexpected response from apollo %s: %s" %
613 (r.status_code, r.text))
614
615 def get(self, clientMethod, get_params):
616 url = self._wa.apollo_url + self.CLIENT_BASE + clientMethod
617 headers = {}
618
619 r = requests.get(url, headers=headers, verify=self.__verify,
620 params=get_params, **self._requestArgs)
621 if r.status_code == 200:
622 d = r.json()
623 if 'username' in d:
624 del d['username']
625 if 'password' in d:
626 del d['password']
627 return d
628 # @see self.body for HTTP response body
629 raise Exception("Unexpected response from apollo %s: %s" %
630 (r.status_code, r.text))
631
632
633 class MetricsClient(Client):
634 CLIENT_BASE = '/metrics/'
635
636 def getServerMetrics(self):
637 return self.get('metrics', {})
638
639
640 class AnnotationsClient(Client):
641 CLIENT_BASE = '/annotationEditor/'
642
643 def _update_data(self, data):
644 if not hasattr(self, '_extra_data'):
645 raise Exception("Please call setSequence first")
646
647 data.update(self._extra_data)
648 return data
649
650 def setSequence(self, sequence, organism):
651 self._extra_data = {
652 'sequence': sequence,
653 'organism': organism,
654 }
655
656 def setDescription(self, featureDescriptions):
657 data = {
658 'features': featureDescriptions,
659 }
660 data = self._update_data(data)
661 return self.request('setDescription', data)
662
663 def setName(self, uniquename, name):
664 # TODO
665 data = {
666 'features': [
667 {
668 'uniquename': uniquename,
669 'name': name,
670 }
671 ],
672 }
673 data = self._update_data(data)
674 return self.request('setName', data)
675
676 def setNames(self, features):
677 # TODO
678 data = {
679 'features': features,
680 }
681 data = self._update_data(data)
682 return self.request('setName', data)
683
684 def setStatus(self, statuses):
685 # TODO
686 data = {
687 'features': statuses,
688 }
689 data = self._update_data(data)
690 return self.request('setStatus', data)
691
692 def setSymbol(self, symbols):
693 data = {
694 'features': symbols,
695 }
696 data.update(self._extra_data)
697 return self.request('setSymbol', data)
698
699 def getComments(self, feature_id):
700 data = {
701 'features': [{'uniquename': feature_id}],
702 }
703 data = self._update_data(data)
704 return self.request('getComments', data)
705
706 def addComments(self, feature_id, comments):
707 # TODO: This is probably not great and will delete comments, if I had to guess...
708 data = {
709 'features': [
710 {
711 'uniquename': feature_id,
712 'comments': comments
713 }
714 ],
715 }
716 data = self._update_data(data)
717 return self.request('addComments', data)
718
719 def addAttributes(self, feature_id, attributes):
720 nrps = []
721 for (key, values) in attributes.items():
722 for value in values:
723 nrps.append({
724 'tag': key,
725 'value': value
726 })
727
728 data = {
729 'features': [
730 {
731 'uniquename': feature_id,
732 'non_reserved_properties': nrps
733 }
734 ]
735 }
736 data = self._update_data(data)
737 return self.request('addAttribute', data)
738
739 def deleteAttribute(self, feature_id, key, value):
740 data = {
741 'features': [
742 {
743 'uniquename': feature_id,
744 'non_reserved_properties': [
745 {'tag': key, 'value': value}
746 ]
747 }
748 ]
749 }
750 data = self._update_data(data)
751 return self.request('addAttribute', data)
752
753 def getFeatures(self):
754 data = self._update_data({})
755 return self.request('getFeatures', data)
756
757 def getSequence(self, uniquename):
758 data = {
759 'features': [
760 {'uniquename': uniquename}
761 ]
762 }
763 data = self._update_data(data)
764 return self.request('getSequence', data)
765
766 def addFeature(self, feature, trustme=False):
767 if not trustme:
768 raise NotImplementedError("Waiting on better docs from project. If you know what you are doing, pass trustme=True to this function.")
769
770 data = {
771 'features': feature,
772 }
773 data = self._update_data(data)
774 return self.request('addFeature', data)
775
776 def addTranscript(self, transcript, trustme=False):
777 if not trustme:
778 raise NotImplementedError("Waiting on better docs from project. If you know what you are doing, pass trustme=True to this function.")
779
780 data = {}
781 data.update(transcript)
782 data = self._update_data(data)
783 return self.request('addTranscript', data)
784
785 # addExon, add/delete/updateComments, addTranscript skipped due to docs
786
787 def duplicateTranscript(self, transcriptId):
788 data = {
789 'features': [{'uniquename': transcriptId}]
790 }
791
792 data = self._update_data(data)
793 return self.request('duplicateTranscript', data)
794
795 def setTranslationStart(self, uniquename, start):
796 data = {
797 'features': [{
798 'uniquename': uniquename,
799 'location': {
800 'fmin': start
801 }
802 }]
803 }
804 data = self._update_data(data)
805 return self.request('setTranslationStart', data)
806
807 def setTranslationEnd(self, uniquename, end):
808 data = {
809 'features': [{
810 'uniquename': uniquename,
811 'location': {
812 'fmax': end
813 }
814 }]
815 }
816 data = self._update_data(data)
817 return self.request('setTranslationEnd', data)
818
819 def setLongestOrf(self, uniquename):
820 data = {
821 'features': [{
822 'uniquename': uniquename,
823 }]
824 }
825 data = self._update_data(data)
826 return self.request('setLongestOrf', data)
827
828 def setBoundaries(self, uniquename, start, end):
829 data = {
830 'features': [{
831 'uniquename': uniquename,
832 'location': {
833 'fmin': start,
834 'fmax': end,
835 }
836 }]
837 }
838 data = self._update_data(data)
839 return self.request('setBoundaries', data)
840
841 def getSequenceAlterations(self):
842 data = {
843 }
844 data = self._update_data(data)
845 return self.request('getSequenceAlterations', data)
846
847 def setReadthroughStopCodon(self, uniquename):
848 data = {
849 'features': [{
850 'uniquename': uniquename,
851 }]
852 }
853 data = self._update_data(data)
854 return self.request('setReadthroughStopCodon', data)
855
856 def deleteSequenceAlteration(self, uniquename):
857 data = {
858 'features': [{
859 'uniquename': uniquename,
860 }]
861 }
862 data = self._update_data(data)
863 return self.request('deleteSequenceAlteration', data)
864
865 def flipStrand(self, uniquenames):
866 data = {
867 'features': [
868 {'uniquename': x} for x in uniquenames
869 ]
870 }
871 data = self._update_data(data)
872 return self.request('flipStrand', data)
873
874 def mergeExons(self, exonA, exonB):
875 data = {
876 'features': [
877 {'uniquename': exonA},
878 {'uniquename': exonB},
879 ]
880 }
881 data = self._update_data(data)
882 return self.request('mergeExons', data)
883
884 # def splitExon(): pass
885
886 def deleteFeatures(self, uniquenames):
887 assert isinstance(uniquenames, collections.Iterable)
888 data = {
889 'features': [
890 {'uniquename': x} for x in uniquenames
891 ]
892 }
893 data = self._update_data(data)
894 return self.request('deleteFeature', data)
895
896 # def deleteExon(): pass
897
898 # def makeIntron(self, uniquename, ): pass
899
900 def getSequenceSearchTools(self):
901 return self.get('getSequenceSearchTools', {})
902
903 def getCannedComments(self):
904 return self.get('getCannedComments', {})
905
906 def searchSequence(self, searchTool, sequence, database):
907 data = {
908 'key': searchTool,
909 'residues': sequence,
910 'database_id': database,
911 }
912 return self.request('searchSequences', data)
913
914 def getGff3(self, uniquenames):
915 assert isinstance(uniquenames, collections.Iterable)
916 data = {
917 'features': [
918 {'uniquename': x} for x in uniquenames
919 ]
920 }
921 data = self._update_data(data)
922 return self.request('getGff3', data, isJson=False)
923
924
925 class GroupsClient(Client):
926 CLIENT_BASE = '/group/'
927
928 def createGroup(self, name):
929 data = {'name': name}
930 return self.request('createGroup', data)
931
932 def getOrganismPermissionsForGroup(self, group):
933 data = {
934 'id': group.groupId,
935 'name': group.name,
936 }
937 return self.request('getOrganismPermissionsForGroup', data)
938
939 def loadGroup(self, group):
940 return self.loadGroupById(group.groupId)
941
942 def loadGroupById(self, groupId):
943 res = self.request('loadGroups', {'groupId': groupId})
944 if isinstance(res, list):
945 # We can only match one, right?
946 return GroupObj(**res[0])
947 else:
948 return res
949
950 def loadGroupByName(self, name):
951 res = self.request('loadGroups', {'name': name})
952 if isinstance(res, list):
953 # We can only match one, right?
954 return GroupObj(**res[0])
955 else:
956 return res
957
958 def loadGroups(self, group=None):
959 res = self.request('loadGroups', {})
960 data = [GroupObj(**x) for x in res]
961 if group is not None:
962 data = [x for x in data if x.name == group]
963
964 return data
965
966 def deleteGroup(self, group):
967 data = {
968 'id': group.groupId,
969 'name': group.name,
970 }
971 return self.request('deleteGroup', data)
972
973 def updateGroup(self, group, newName):
974 # TODO: Sure would be nice if modifying ``group.name`` would invoke
975 # this?
976 data = {
977 'id': group.groupId,
978 'name': newName,
979 }
980 return self.request('updateGroup', data)
981
982 def updateOrganismPermission(self, group, organismName,
983 administrate=False, write=False, read=False,
984 export=False):
985 data = {
986 'groupId': group.groupId,
987 'organism': organismName,
988 'ADMINISTRATE': administrate,
989 'WRITE': write,
990 'EXPORT': export,
991 'READ': read,
992 }
993 return self.request('updateOrganismPermission', data)
994
995 def updateMembership(self, group, users):
996 data = {
997 'groupId': group.groupId,
998 'user': [user.email for user in users]
999 }
1000 return self.request('updateMembership', data)
1001
1002
1003 class IOClient(Client):
1004 CLIENT_BASE = '/IOService/'
1005
1006 def write(self, exportType='FASTA', seqType='peptide',
1007 exportFormat='text', sequences=None, organism=None,
1008 output='text', exportAllSequences=False,
1009 exportGff3Fasta=False):
1010 if exportType not in ('FASTA', 'GFF3'):
1011 raise Exception("exportType must be one of FASTA, GFF3")
1012
1013 if seqType not in ('peptide', 'cds', 'cdna', 'genomic'):
1014 raise Exception("seqType must be one of peptide, cds, dna, genomic")
1015
1016 if exportFormat not in ('gzip', 'text'):
1017 raise Exception("exportFormat must be one of gzip, text")
1018
1019 if output not in ('file', 'text'):
1020 raise Exception("output must be one of file, text")
1021
1022 data = {
1023 'type': exportType,
1024 'seqType': seqType,
1025 'format': exportFormat,
1026 'sequences': sequences,
1027 'organism': organism,
1028 'output': output,
1029 'exportAllSequences': exportAllSequences,
1030 'exportGff3Fasta': exportGff3Fasta,
1031 }
1032
1033 return self.request('write', data, isJson=output == 'file')
1034
1035 def download(self, uuid, outputFormat='gzip'):
1036
1037 if outputFormat.lower() not in ('gzip', 'text'):
1038 raise Exception("outputFormat must be one of file, text")
1039
1040 data = {
1041 'format': outputFormat,
1042 'uuid': uuid,
1043 }
1044 return self.request('write', data)
1045
1046
1047 class StatusClient(Client):
1048 CLIENT_BASE = '/availableStatus/'
1049
1050 def addStatus(self, value):
1051 data = {
1052 'value': value
1053 }
1054
1055 return self.request('createStatus', data)
1056
1057 def findAllStatuses(self):
1058 return self.request('showStatus', {})
1059
1060 def findStatusByValue(self, value):
1061 statuses = self.findAllStatuses()
1062 statuses = [x for x in statuses if x['value'] == value]
1063 if len(statuses) == 0:
1064 raise Exception("Unknown status value")
1065 else:
1066 return statuses[0]
1067
1068 def findStatusById(self, id_number):
1069 statuses = self.findAllStatuses()
1070 statuses = [x for x in statuses if str(x['id']) == str(id_number)]
1071 if len(statuses) == 0:
1072 raise Exception("Unknown ID")
1073 else:
1074 return statuses[0]
1075
1076 def updateStatus(self, id_number, new_value):
1077 data = {
1078 'id': id_number,
1079 'new_value': new_value
1080 }
1081
1082 return self.request('updateStatus', data)
1083
1084 def deleteStatus(self, id_number):
1085 data = {
1086 'id': id_number
1087 }
1088
1089 return self.request('deleteStatus', data)
1090
1091
1092 class CannedCommentsClient(Client):
1093 CLIENT_BASE = '/cannedComment/'
1094
1095 def addComment(self, comment, metadata=""):
1096 data = {
1097 'comment': comment,
1098 'metadata': metadata
1099 }
1100
1101 return self.request('createComment', data)
1102
1103 def findAllComments(self):
1104 return self.request('showComment', {})
1105
1106 def findCommentByValue(self, value):
1107 comments = self.findAllComments()
1108 comments = [x for x in comments if x['comment'] == value]
1109 if len(comments) == 0:
1110 raise Exception("Unknown comment")
1111 else:
1112 return comments[0]
1113
1114 def findCommentById(self, id_number):
1115 comments = self.findAllComments()
1116 comments = [x for x in comments if str(x['id']) == str(id_number)]
1117 if len(comments) == 0:
1118 raise Exception("Unknown ID")
1119 else:
1120 return comments[0]
1121
1122 def updateComment(self, id_number, new_value, metadata=None):
1123 data = {
1124 'id': id_number,
1125 'new_comment': new_value
1126 }
1127
1128 if metadata is not None:
1129 data['metadata'] = metadata
1130
1131 return self.request('updateComment', data)
1132
1133 def deleteComment(self, id_number):
1134 data = {
1135 'id': id_number
1136 }
1137
1138 return self.request('deleteComment', data)
1139
1140
1141 class CannedKeysClient(Client):
1142 CLIENT_BASE = '/cannedKey/'
1143
1144 def addKey(self, key, metadata=""):
1145 data = {
1146 'key': key,
1147 'metadata': metadata
1148 }
1149
1150 return self.request('createKey', data)
1151
1152 def findAllKeys(self):
1153 return self.request('showKey', {})
1154
1155 def findKeyByValue(self, value):
1156 keys = self.findAllKeys()
1157 keys = [x for x in keys if x['label'] == value]
1158 if len(keys) == 0:
1159 raise Exception("Unknown key")
1160 else:
1161 return keys[0]
1162
1163 def findKeyById(self, id_number):
1164 keys = self.findAllKeys()
1165 keys = [x for x in keys if str(x['id']) == str(id_number)]
1166 if len(keys) == 0:
1167 raise Exception("Unknown ID")
1168 else:
1169 return keys[0]
1170
1171 def updateKey(self, id_number, new_key, metadata=None):
1172 data = {
1173 'id': id_number,
1174 'new_key': new_key
1175 }
1176
1177 if metadata is not None:
1178 data['metadata'] = metadata
1179
1180 return self.request('updateKey', data)
1181
1182 def deleteKey(self, id_number):
1183 data = {
1184 'id': id_number
1185 }
1186
1187 return self.request('deleteKey', data)
1188
1189
1190 class CannedValuesClient(Client):
1191 CLIENT_BASE = '/cannedValue/'
1192
1193 def addValue(self, value, metadata=""):
1194 data = {
1195 'value': value,
1196 'metadata': metadata
1197 }
1198
1199 return self.request('createValue', data)
1200
1201 def findAllValues(self):
1202 return self.request('showValue', {})
1203
1204 def findValueByValue(self, value):
1205 values = self.findAllValues()
1206 values = [x for x in values if x['label'] == value]
1207 if len(values) == 0:
1208 raise Exception("Unknown value")
1209 else:
1210 return values[0]
1211
1212 def findValueById(self, id_number):
1213 values = self.findAllValues()
1214 values = [x for x in values if str(x['id']) == str(id_number)]
1215 if len(values) == 0:
1216 raise Exception("Unknown ID")
1217 else:
1218 return values[0]
1219
1220 def updateValue(self, id_number, new_value, metadata=None):
1221 data = {
1222 'id': id_number,
1223 'new_value': new_value
1224 }
1225
1226 if metadata is not None:
1227 data['metadata'] = metadata
1228
1229 return self.request('updateValue', data)
1230
1231 def deleteValue(self, id_number):
1232 data = {
1233 'id': id_number
1234 }
1235
1236 return self.request('deleteValue', data)
1237
1238
1239 class OrganismsClient(Client):
1240 CLIENT_BASE = '/organism/'
1241
1242 def addOrganism(self, commonName, directory, blatdb=None, species=None,
1243 genus=None, public=False):
1244 data = {
1245 'commonName': commonName,
1246 'directory': directory,
1247 'publicMode': public,
1248 }
1249
1250 if blatdb is not None:
1251 data['blatdb'] = blatdb
1252 if genus is not None:
1253 data['genus'] = genus
1254 if species is not None:
1255 data['species'] = species
1256
1257 return self.request('addOrganism', data)
1258
1259 def findAllOrganisms(self):
1260 return self.request('findAllOrganisms', {})
1261
1262 def findOrganismByCn(self, cn):
1263 orgs = self.findAllOrganisms()
1264 orgs = [x for x in orgs if x['commonName'] == cn]
1265 if len(orgs) == 0:
1266 raise Exception("Unknown common name")
1267 else:
1268 return orgs[0]
1269
1270 def findOrganismById(self, id_number):
1271 orgs = self.findAllOrganisms()
1272 orgs = [x for x in orgs if str(x['id']) == str(id_number)]
1273 if len(orgs) == 0:
1274 raise Exception("Unknown ID")
1275 else:
1276 return orgs[0]
1277
1278 def deleteOrganism(self, organismId):
1279 return self.request('deleteOrganism', {'id': organismId})
1280
1281 def deleteOrganismFeatures(self, organismId):
1282 return self.request('deleteOrganismFeatures', {'id': organismId})
1283
1284 def getSequencesForOrganism(self, commonName):
1285 return self.request('getSequencesForOrganism', {'organism': commonName})
1286
1287 def updateOrganismInfo(self, organismId, commonName, directory, blatdb=None, species=None, genus=None, public=False):
1288 data = {
1289 'id': organismId,
1290 'name': commonName,
1291 'directory': directory,
1292 'publicMode': public,
1293 }
1294
1295 if blatdb is not None:
1296 data['blatdb'] = blatdb
1297 if genus is not None:
1298 data['genus'] = genus
1299 if species is not None:
1300 data['species'] = species
1301
1302 return self.request('updateOrganismInfo', data)
1303
1304
1305 class UsersClient(Client):
1306 CLIENT_BASE = '/user/'
1307
1308 # Real one
1309 # def getOrganismPermissionsForUser(self, user):
1310 # data = {
1311 # 'userId': user.userId,
1312 # }
1313 # return self.request('getOrganismPermissionsForUser', data)
1314
1315 # Utter frigging hack
1316 def getOrganismPermissionsForUser(self, user):
1317 return self.loadUser(user).organismPermissions
1318
1319 def updateOrganismPermission(self, user, organism, administrate=False,
1320 write=False, export=False, read=False):
1321 data = {
1322 'userId': user.userId,
1323 'organism': organism,
1324 'ADMINISTRATE': administrate,
1325 'WRITE': write,
1326 'EXPORT': export,
1327 'READ': read,
1328 }
1329 return self.request('updateOrganismPermission', data)
1330
1331 def loadUser(self, user):
1332 return self.loadUserById(user.userId)
1333
1334 def loadUserById(self, userId):
1335 res = self.request('loadUsers', {'userId': userId})
1336 if isinstance(res, list):
1337 # We can only match one, right?
1338 return UserObj(**res[0])
1339 else:
1340 return res
1341
1342 def loadUsers(self, email=None):
1343 res = self.request('loadUsers', {})
1344 data = [UserObj(**x) for x in res]
1345 if email is not None:
1346 data = [x for x in data if x.username == email]
1347
1348 return data
1349
1350 def addUserToGroup(self, group, user):
1351 data = {'group': group.name, 'userId': user.userId}
1352 return self.request('addUserToGroup', data)
1353
1354 def removeUserFromGroup(self, group, user):
1355 data = {'group': group.name, 'userId': user.userId}
1356 return self.request('removeUserFromGroup', data)
1357
1358 def createUser(self, email, firstName, lastName, newPassword, role="user", groups=None):
1359 data = {
1360 'firstName': firstName,
1361 'lastName': lastName,
1362 'email': email,
1363 'role': role,
1364 'groups': [] if groups is None else groups,
1365 # 'availableGroups': [],
1366 'newPassword': newPassword,
1367 # 'organismPermissions': [],
1368 }
1369 return self.request('createUser', data)
1370
1371 def deleteUser(self, user):
1372 return self.request('deleteUser', {'userId': user.userId})
1373
1374 def updateUser(self, user, email, firstName, lastName, newPassword):
1375 data = {
1376 'userId': user.userId,
1377 'email': email,
1378 'firstName': firstName,
1379 'lastName': lastName,
1380 'newPassword': newPassword,
1381 }
1382 return self.request('updateUser', data)
1383
1384
1385 class RemoteRecord(Client):
1386 CLIENT_BASE = None
1387
1388 def ParseRecord(self, cn):
1389 org = self._wa.organisms.findOrganismByCn(cn)
1390 self._wa.annotations.setSequence(org['commonName'], org['id'])
1391
1392 data = io.StringIO(self._wa.io.write(
1393 exportType='GFF3',
1394 seqType='genomic',
1395 exportAllSequences=False,
1396 exportGff3Fasta=True,
1397 output="text",
1398 exportFormat="text",
1399 sequences=cn,
1400 ))
1401 data.seek(0)
1402
1403 for record in GFF.parse(data):
1404 yield WebApolloSeqRecord(record, self._wa)
1405
1406
1407 class WebApolloSeqRecord(object):
1408 def __init__(self, sr, wa):
1409 self._sr = sr
1410 self._wa = wa
1411
1412 def __dir__(self):
1413 return dir(self._sr)
1414
1415 def __getattr__(self, key):
1416 if key in ('_sr', '_wa'):
1417 return self.__dict__[key]
1418 else:
1419 if key == 'features':
1420 return (WebApolloSeqFeature(x, self._wa)
1421 for x in self._sr.__dict__[key])
1422 else:
1423 return self._sr.__dict__[key]
1424
1425 def __setattr__(self, key, value):
1426 if key in ('_sd', '_wa'):
1427 self.__dict__[key] = value
1428 else:
1429 self._sr.__dict__[key] = value
1430 # Methods acting on the SeqRecord object
1431
1432
1433 class WebApolloSeqFeature(object):
1434 def __init__(self, sf, wa):
1435 self._sf = sf
1436 self._wa = wa
1437
1438 def __dir__(self):
1439 return dir(self._sf)
1440
1441 def __getattr__(self, key):
1442 if key in ('_sf', '_wa'):
1443 return self.__dict__[key]
1444 else:
1445 return self._sf.__dict__[key]
1446
1447 def __setattr__(self, key, value):
1448 if key in ('_sf', '_wa'):
1449 self.__dict__[key] = value
1450 else:
1451 # Methods acting on the SeqFeature object
1452 if key == 'location':
1453 if value.strand != self._sf.location.strand:
1454 self.wa.annotations.flipStrand(
1455 self._sf.qualifiers['ID'][0]
1456 )
1457
1458 self.wa.annotations.setBoundaries(
1459 self._sf.qualifiers['ID'][0],
1460 value.start,
1461 value.end,
1462 )
1463
1464 self._sf.__dict__[key] = value
1465 else:
1466 self._sf.__dict__[key] = value
1467
1468
1469 def _tnType(feature):
1470 if feature.type in ('gene', 'mRNA', 'exon', 'CDS', 'terminator', 'tRNA'):
1471 return feature.type
1472 else:
1473 return 'exon'
1474
1475
1476 def _yieldFeatData(features):
1477 for f in features:
1478 current = {
1479 'location': {
1480 'strand': f.strand,
1481 'fmin': int(f.location.start),
1482 'fmax': int(f.location.end),
1483 },
1484 'type': {
1485 'name': _tnType(f),
1486 'cv': {
1487 'name': 'sequence',
1488 }
1489 },
1490 }
1491 if f.type in ('gene', 'mRNA'):
1492 current['name'] = f.qualifiers.get('Name', [f.id])[0]
1493 if hasattr(f, 'sub_features') and len(f.sub_features) > 0:
1494 current['children'] = [x for x in _yieldFeatData(f.sub_features)]
1495
1496 yield current
1497
1498
1499 def featuresToFeatureSchema(features):
1500 compiled = []
1501 for feature in features:
1502 # if feature.type != 'gene':
1503 # log.warn("Not able to handle %s features just yet...", feature.type)
1504 # continue
1505
1506 for x in _yieldFeatData([feature]):
1507 compiled.append(x)
1508 return compiled
1509
1510
1511 def accessible_organisms(user, orgs):
1512 permissionMap = {
1513 x['organism']: x['permissions']
1514 for x in user.organismPermissions
1515 if 'WRITE' in x['permissions'] or
1516 'READ' in x['permissions'] or
1517 'ADMINISTRATE' in x['permissions'] or
1518 user.role == 'ADMIN'
1519 }
1520
1521 if 'error' in orgs:
1522 raise Exception("Error received from Apollo server: \"%s\"" % orgs['error'])
1523
1524 return [
1525 (org['commonName'], org['id'], False)
1526 for org in sorted(orgs, key=lambda x: x['commonName'])
1527 if org['commonName'] in permissionMap
1528 ]
1529
1530
1531 def galaxy_list_groups(trans, *args, **kwargs):
1532 email = trans.get_user().email
1533 wa = WebApolloInstance(
1534 os.environ['GALAXY_WEBAPOLLO_URL'],
1535 os.environ['GALAXY_WEBAPOLLO_USER'],
1536 os.environ['GALAXY_WEBAPOLLO_PASSWORD']
1537 )
1538 # Assert that the email exists in apollo
1539 try:
1540 gx_user = wa.requireUser(email)
1541 except UnknownUserException:
1542 return []
1543
1544 # Key for cached data
1545 cacheKey = 'groups-' + email
1546 # We don't want to trust "if key in cache" because between asking and fetch
1547 # it might through key error.
1548 if cacheKey not in cache:
1549 # However if it ISN'T there, we know we're safe to fetch + put in
1550 # there.
1551 data = _galaxy_list_groups(wa, gx_user, *args, **kwargs)
1552 cache[cacheKey] = data
1553 return data
1554 try:
1555 # The cache key may or may not be in the cache at this point, it
1556 # /likely/ is. However we take no chances that it wasn't evicted between
1557 # when we checked above and now, so we reference the object from the
1558 # cache in preparation to return.
1559 data = cache[cacheKey]
1560 return data
1561 except KeyError:
1562 # If access fails due to eviction, we will fail over and can ensure that
1563 # data is inserted.
1564 data = _galaxy_list_groups(wa, gx_user, *args, **kwargs)
1565 cache[cacheKey] = data
1566 return data
1567
1568
1569 def _galaxy_list_groups(wa, gx_user, *args, **kwargs):
1570 # Fetch the groups.
1571 group_data = []
1572 for group in wa.groups.loadGroups():
1573 # Reformat
1574 group_data.append((group.name, group.groupId, False))
1575 return group_data
1576
1577
1578 def galaxy_list_orgs(trans, *args, **kwargs):
1579 email = trans.get_user().email
1580 wa = WebApolloInstance(
1581 os.environ['GALAXY_WEBAPOLLO_URL'],
1582 os.environ['GALAXY_WEBAPOLLO_USER'],
1583 os.environ['GALAXY_WEBAPOLLO_PASSWORD']
1584 )
1585 try:
1586 gx_user = wa.requireUser(email)
1587 except UnknownUserException:
1588 return []
1589
1590 # Key for cached data
1591 cacheKey = 'orgs-' + email
1592 if cacheKey not in cache:
1593 data = _galaxy_list_orgs(wa, gx_user, *args, **kwargs)
1594 cache[cacheKey] = data
1595 return data
1596 try:
1597 data = cache[cacheKey]
1598 return data
1599 except KeyError:
1600 data = _galaxy_list_orgs(wa, gx_user, *args, **kwargs)
1601 cache[cacheKey] = data
1602 return data
1603
1604
1605 def _galaxy_list_orgs(wa, gx_user, *args, **kwargs):
1606 # Fetch all organisms
1607 all_orgs = wa.organisms.findAllOrganisms()
1608 # Figure out which are accessible to the user
1609 orgs = accessible_organisms(gx_user, all_orgs)
1610 # Return org list
1611 return orgs
1612
1613
1614 def galaxy_list_users(trans, *args, **kwargs):
1615 email = trans.get_user().email
1616 wa = WebApolloInstance(
1617 os.environ['GALAXY_WEBAPOLLO_URL'],
1618 os.environ['GALAXY_WEBAPOLLO_USER'],
1619 os.environ['GALAXY_WEBAPOLLO_PASSWORD']
1620 )
1621 # Assert that the email exists in apollo
1622 try:
1623 gx_user = wa.requireUser(email)
1624 except UnknownUserException:
1625 return []
1626
1627 # Key for cached data
1628 cacheKey = 'users-' + email
1629 # We don't want to trust "if key in cache" because between asking and fetch
1630 # it might through key error.
1631 if cacheKey not in cache:
1632 # However if it ISN'T there, we know we're safe to fetch + put in
1633 # there.
1634 data = _galaxy_list_users(wa, gx_user, *args, **kwargs)
1635 cache[cacheKey] = data
1636 return data
1637 try:
1638 # The cache key may or may not be in the cache at this point, it
1639 # /likely/ is. However we take no chances that it wasn't evicted between
1640 # when we checked above and now, so we reference the object from the
1641 # cache in preparation to return.
1642 data = cache[cacheKey]
1643 return data
1644 except KeyError:
1645 # If access fails due to eviction, we will fail over and can ensure that
1646 # data is inserted.
1647 data = _galaxy_list_users(wa, gx_user, *args, **kwargs)
1648 cache[cacheKey] = data
1649 return data
1650
1651
1652 def _galaxy_list_users(wa, gx_user, *args, **kwargs):
1653 # Fetch the users.
1654 user_data = []
1655 for user in wa.users.loadUsers():
1656 # Reformat
1657 user_data.append((user.username, user.username, False))
1658 return user_data
1659
1660
1661 # This is all for implementing the command line interface for testing.
1662 class obj(object):
1663 pass
1664
1665
1666 class fakeTrans(object):
1667
1668 def __init__(self, username):
1669 self.un = username
1670
1671 def get_user(self):
1672 o = obj()
1673 o.email = self.un
1674 return o
1675
1676
1677 def retry(closure, sleep=1, limit=5):
1678 """
1679 Apollo has the bad habit of returning 500 errors if you call APIs
1680 too quickly, largely because of the unholy things that happen in
1681 grails.
1682
1683 To deal with the fact that we cannot send an addComments call too
1684 quickly after a createFeature call, we have this function that will
1685 keep calling a closure until it works.
1686 """
1687 count = 0
1688 while True:
1689 count += 1
1690
1691 if count >= limit:
1692 return False
1693 try:
1694 # Try calling it
1695 closure()
1696 # If successful, exit
1697 return True
1698 except Exception as e:
1699 log.info(str(e)[0:100])
1700 time.sleep(sleep)
1701
1702
1703 if __name__ == '__main__':
1704 parser = argparse.ArgumentParser(description='Test access to apollo server')
1705 parser.add_argument('email', help='Email of user to test')
1706 parser.add_argument('--action', choices=['org', 'group', 'users'], default='org', help='Data set to test, fetch a list of groups or users known to the requesting user.')
1707 args = parser.parse_args()
1708
1709 trans = fakeTrans(args.email)
1710 if args.action == 'org':
1711 for f in galaxy_list_orgs(trans):
1712 print(f)
1713 elif args.action == 'group':
1714 for f in galaxy_list_groups(trans):
1715 print(f)
1716 else:
1717 for f in galaxy_list_users(trans):
1718 print(f)