1
2
3
4
5
6
7
8
9
10
11
12
13 import os,sys
14 THISPATH = os.path.dirname(os.path.abspath(__file__))
15
16 from types import IntType, LongType, UnicodeType, ListType, TupleType, StringType, StringTypes
17 from datetime import datetime
18 from cStringIO import StringIO
19 import ConfigParser
20
21 import omero
22 import omero.clients
23 import Ice
24 import Glacier2
25
26 import traceback
27 import time
28 import array
29
30 import logging
31 logger = logging.getLogger('blitz_gateway')
32
33 try:
34 from PIL import Image, ImageDraw, ImageFont
35 except ImportError:
36 try:
37 import Image, ImageDraw, ImageFont
38 except:
39 logger.error('No PIL installed, line plots and split channel will fail!')
40
41 from cStringIO import StringIO
42 from math import sqrt
43
44 import omero_Constants_ice
45 import omero_ROMIO_ice
46 from omero.rtypes import *
49 """
50 Converts rtypes from static factory methods:
51 - StringType to rstring
52 - UnicodeType to rstring
53 - IntType to rint
54 - LongType to rlong
55 elswere return the argument itself
56
57 @param val: value
58 @return: matched RType or value
59 """
60
61 if isinstance(val, StringType):
62 return rstring(val)
63 elif isinstance(val, UnicodeType):
64 return rstring(val.encode('utf-8'))
65 elif isinstance(val, IntType):
66 return rint(val)
67 elif isinstance(val, LongType):
68 return rlong(val)
69 else:
70 return val
71
73 """
74 Decorator to measure the execution time of a function.
75
76 @param level: the level to use for logging
77 """
80
82 def wrapped (*args, **kwargs):
83 logger.log(self._level, "timing %s" % (func.func_name))
84 now = time.time()
85 rv = func(*args, **kwargs)
86 logger.log(self._level, "timed %s: %f" % (func.func_name, time.time()-now))
87 return rv
88 return wrapped
89
91 """
92 Measures the execution time of a function using time.time()
93 and the a @ function decorator.
94
95 Logs at logging.DEBUG level.
96 """
97 def wrapped (*args, **kwargs):
98 logger.log(self._level, "timing %s" % (func.func_name))
99 now = time.time()
100 rv = func(*args, **kwargs)
101 logger.log(self._level, "timed %s: %f" % (func.func_name, time.time()-now))
102 return rv
103 return TimeIt()(func)
104
109 """
110 Object wrapper class.
111 """
112
113 OMERO_CLASS = None
114 LINK_CLASS = None
115 CHILD_WRAPPER_CLASS = None
116 PARENT_WRAPPER_CLASS = None
117
118 - def __init__ (self, conn=None, obj=None, cache={}, **kwargs):
119 self.__bstrap__()
120 self._obj = obj
121 self._cache = cache
122 self._conn = conn
123 if conn is None:
124 return
125 if hasattr(obj, 'id') and obj.id is not None:
126 self._oid = obj.id.val
127 if not self._obj.loaded:
128 try:
129 self._obj = self._conn.getQueryService().get(self._obj.__class__.__name__, self._oid)
130 except:
131 print traceback.format_exc()
132 self.__prepare__ (**kwargs)
133
136
139
142
147
158
169
172
173
175 p = self.listParents()
176 link = self._conn.getQueryService().findAllByQuery("select l from %s as l where l.parent.id=%i and l.child.id=%i" % (p.LINK_CLASS, p.id, self.id), None)
177 if len(link):
178 return link[0]
179 return None
180
182 """ moves this object from the current parent container to a new one """
183 p = self.listParents()
184 if type(p) == type(newParent):
185 link = self._conn.getQueryService().findAllByQuery("select l from %s as l where l.parent.id=%i and l.child.id=%i" % (p.LINK_CLASS, p.id, self.id), None)
186 if len(link):
187 link[0].parent = newParent._obj
188 self._conn.getUpdateService().saveObject(link[0])
189 return True
190 return False
191
198
203
205 try:
206 if self._obj.acquisitionDate.val is not None and self._obj.acquisitionDate.val > 0:
207 t = self._obj.acquisitionDate.val
208 else:
209 t = self._obj.details.creationEvent.time.val
210 except:
211 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val
212 return datetime.fromtimestamp(t/1000)
213
216
240
242 return self._conn.canWrite(self._obj)
243
245 return self._obj.details.permissions.isUserWrite()
246
249
251 return (self._obj.details.owner.id.val == self._conn.getEventContext().userId)
252
254 if self._obj.details.group.id.val in self._conn.getEventContext().leaderOfGroups:
255 return True
256 return False
257
264
266 return self._obj.details.permissions.isWorldRead()
267
269 if not self.isPublic():
270 return self._obj.details.permissions.isGroupRead()
271 return False
272
274 if not self.isPublic() and not self.isShared():
275 return self._obj.details.permissions.isUserRead()
276 return False
277
279 if self.isPublic() and not self._obj.details.permissions.isWorldWrite():
280 return True
281 elif self.isShared() and not self._obj.details.permissions.isGroupWrite():
282 return True
283 elif self.isPrivate() and not self._obj.details.permissions.isUserWrite():
284 return True
285 return False
286
287
288
289
290
291
292
293
294
295
296
297
298
300 """
301 Counts available number of child objects.
302
303 @return: Long. The number of child objects available
304 """
305
306 childw = self._getChildWrapper()
307 klass = "%sLinks" % childw().OMERO_CLASS.lower()
308
309 self._cached_countChildren = self._conn.getContainerService().getCollectionCount(self.OMERO_CLASS, klass, [self._oid], None)[self._oid]
310 return self._cached_countChildren
311
313 """
314 countChildren, but caching the first result, useful if you need to call this multiple times in
315 a single sequence, but have no way of storing the value between them.
316 It is actually a hack to support django template's lack of break in for loops
317
318 @return: Long
319 """
320
321 if not hasattr(self, '_cached_countChildren'):
322 return self.countChildren()
323 return self._cached_countChildren
324
326 """
327 Lists available child objects.
328
329 @return: Generator yielding child objects.
330 """
331
332 childw = self._getChildWrapper()
333 klass = childw().OMERO_CLASS
334
335
336
337
338
339 if not params:
340 params = omero.sys.Parameters()
341 if not params.map:
342 params.map = {}
343 params.map["dsid"] = omero_type(self._oid)
344 query = "select c from %s as c" % self.LINK_CLASS
345 if ns is not None:
346 params.map["ns"] = omero_type(ns)
347
348
349 query += """ join fetch c.child as ch
350 left outer join fetch ch.annotationLinks as ial
351 left outer join fetch ial.child as a """
352 query += " where c.parent.id=:dsid"
353 if ns is not None:
354 query += " and a.ns=:ns"
355 if val is not None:
356 if isinstance(val, StringTypes):
357 params.map["val"] = omero_type(val)
358 query +=" and a.textValue=:val"
359 query += " order by c.child.name"
360 childnodes = [ x.child for x in self._conn.getQueryService().findAllByQuery(query, params)]
361 for child in childnodes:
362 yield childw(self._conn, child, self._cache)
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
382 """
383 Lists available parent objects.
384
385 @return: Generator yielding parent objects
386 """
387
388 if self.PARENT_WRAPPER_CLASS is None:
389 if single:
390 return withlinks and (None, None) or None
391 return ()
392 parentw = self._getParentWrapper()
393 param = omero.sys.Parameters()
394 if withlinks:
395 parentnodes = [ (parentw(self._conn, x.parent, self._cache), BlitzObjectWrapper(self._conn, x)) for x in self._conn.getQueryService().findAllByQuery("from %s as c where c.child.id=%i" % (parentw().LINK_CLASS, self._oid), param)]
396 else:
397 parentnodes = [ parentw(self._conn, x.parent, self._cache) for x in self._conn.getQueryService().findAllByQuery("from %s as c where c.child.id=%i" % (parentw().LINK_CLASS, self._oid), param)]
398 if single:
399 return len(parentnodes) and parentnodes[0] or None
400 return parentnodes
401
402
410
411
413 if not hasattr(self._obj, 'isAnnotationLinksLoaded'):
414 raise NotImplementedError
415 if not self._obj.isAnnotationLinksLoaded():
416 links = self._conn.getQueryService().findAllByQuery("select l from %sAnnotationLink as l join fetch l.child as a where l.parent.id=%i" % (self.OMERO_CLASS, self._oid), None)
417 self._obj._annotationLinksLoaded = True
418 self._obj._annotationLinksSeq = links
419
420
422 self._loadAnnotationLinks()
423 rv = self.copyAnnotationLinks()
424 if ns is not None:
425 rv = filter(lambda x: x.getChild().getNs() and x.getChild().getNs().val == ns, rv)
426 return rv
427
428
436
438 """
439 ets the first annotation in the ns namespace, linked to this object
440
441 @return: #AnnotationWrapper or None
442 """
443 rv = self._getAnnotationLinks(ns)
444 if len(rv):
445 return AnnotationWrapper._wrap(self._conn, rv[0].child)
446 return None
447
449 """
450 List annotations in the ns namespace, linked to this object
451
452 @return: Generator yielding AnnotationWrapper
453 """
454
455 for ann in self._getAnnotationLinks(ns):
456 yield AnnotationWrapper._wrap(self._conn, ann.child, link=ann)
457
458
460 if not ann.getId():
461
462 ann.details.setPermissions(omero.model.PermissionsI())
463 ann.details.permissions.setWorldRead(True)
464 ann.details.permissions.setGroupWrite(True)
465 ann = ann.__class__(self._conn, self._conn.getUpdateService().saveAndReturnObject(ann._obj))
466
467
468 lnktype = "%sAnnotationLinkI" % self.OMERO_CLASS
469 lnk = getattr(omero.model, lnktype)()
470 lnk.details.setPermissions(omero.model.PermissionsI())
471 lnk.details.permissions.setWorldRead(True)
472 lnk.details.permissions.setGroupWrite(True)
473 lnk.details.permissions.setUserWrite(True)
474 lnk.setParent(self._obj.__class__(self._obj.id, False))
475 lnk.setChild(ann._obj.__class__(ann._obj.id, False))
476 self._conn.getUpdateService().saveObject(lnk)
477 return ann
478
479
512
513
515 rv = {'type': self.OMERO_CLASS,
516 'id': self.getId(),
517 'name': self.getName(),
518 'description': self.getDescription(),
519 }
520 if hasattr(self, '_attrs'):
521
522
523
524
525 for k in self._attrs:
526 if ';' in k:
527 s = k.split(';')
528 k = s[0]
529 rk = ';'.join(s[1:])
530 else:
531 rk = k
532 rk = rk.replace('#', '')
533 if '|' in k:
534 s = k.split('|')
535 k2 = s[0]
536 w = '|'.join(s[1:])
537 if rk == k:
538 rk = k2
539 k = k2
540
541 v = getattr(self, k)
542 if v is not None:
543 v = getattr(omero.gateway, w)(self._conn, v).simpleMarshal()
544 else:
545 if k.startswith('#'):
546 v = getattr(self, k[1:])
547 if v is not None:
548 v = v._value
549 else:
550 v = getattr(self, k)
551 if hasattr(v, 'val'):
552 v = v.val
553 rv[rk] = v
554 if xtra:
555 if xtra.has_key('childCount'):
556 rv['child_count'] = self.countChildren()
557 if parents:
558 rv['parents'] = map(lambda x: x.simpleMarshal(), self.getAncestry())
559 return rv
560
561
562
563
564
565
567 if attr != 'get' and attr.startswith('get') and hasattr(self, '_attrs'):
568 tattr = attr[3].lower() + attr[4:]
569 attrs = filter(lambda x: tattr in x, self._attrs)
570 for a in attrs:
571 if a.startswith('#') and a[1:] == tattr:
572
573 v = getattr(self, tattr)
574 if v is not None:
575 v = v._value
576 def wrap ():
577 return v
578 return wrap
579 if len(a) > len(tattr) and a[len(tattr)] == '|':
580 def wrap ():
581 return getattr(omero.gateway, a[len(tattr)+1:])(self._conn, getattr(self, tattr))
582 return wrap
583 if not hasattr(self._obj, attr) and hasattr(self._obj, '_'+attr):
584 attr = '_' + attr
585 if hasattr(self._obj, attr):
586 rv = getattr(self._obj, attr)
587 if hasattr(rv, 'val'):
588 return isinstance(rv.val, StringType) and rv.val.decode('utf8') or rv.val
589 return rv
590 raise AttributeError("'%s' object has no attribute '%s'" % (self._obj.__class__.__name__, attr))
591
592
593
594
596 """
597 Gets this object ID
598
599 @return: Long or None
600 """
601 oid = self._obj.getId()
602 if oid is not None:
603 return oid.val
604 return None
605
607 """
608 Gets this object name
609
610 @return: String or None
611 """
612 if hasattr(self._obj, 'name'):
613 if hasattr(self._obj.name, 'val'):
614 return self._obj.getName().val
615 else:
616 return self._obj.getName()
617 else:
618 return None
619
621 """
622 Gets this object description
623
624 @return: String
625 """
626
627 rv = hasattr(self._obj, 'description') and self._obj.getDescription() or None
628 return rv and rv.val or ''
629
631 """
632 Gets user who is the owner of this object.
633
634 @return: _ExperimenterWrapper
635 """
636
637 return self.getDetails().getOwner()
638
640 """
641 Gets full name of the owner of this object.
642
643 @return: String or None
644 """
645
646 try:
647 lastName = self.getDetails().getOwner().lastName
648 firstName = self.getDetails().getOwner().firstName
649 middleName = self.getDetails().getOwner().middleName
650
651 if middleName is not None and middleName != '':
652 name = "%s %s. %s" % (firstName, middleName, lastName)
653 else:
654 name = "%s %s" % (firstName, lastName)
655 return name
656 except:
657 logger.error(traceback.format_exc())
658 return None
659
661 """
662 Gets omeName of the owner of this object.
663
664 @return: String
665 """
666 return self.getDetails().getOwner().omeName
667
669 """
670 Gets event time in timestamp format (yyyy-mm-dd hh:mm:ss.fffffff) when object was created.
671
672 @return: Long
673 """
674
675 try:
676 if self._obj.details.creationEvent.time is not None:
677 t = self._obj.details.creationEvent.time.val
678 else:
679 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val
680 except:
681 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val
682 return datetime.fromtimestamp(t/1000)
683
685 """
686 Gets event time in timestamp format (yyyy-mm-dd hh:mm:ss.fffffff) when object was updated.
687
688 @return: Long
689 """
690
691 try:
692 if self._obj.details.updateEvent.time is not None:
693 t = self._obj.details.updateEvent.time.val
694 else:
695 t = self._conn.getQueryService().get("Event", self._obj.details.updateEvent.id.val).time.val
696 except:
697 t = self._conn.getQueryService().get("Event", self._obj.details.updateEvent.id.val).time.val
698 return datetime.fromtimestamp(t/1000)
699
700
701
702
705
708
713 raise Ice.ConnectionLostException
714
716 """
717 ICE_CONFIG - Defines the path to the Ice configuration
718 """
719
720 ICE_CONFIG = None
721
722
723 - def __init__ (self, username=None, passwd=None, client_obj=None, group=None, clone=False, try_super=False, host=None, port=None, extra_config=[], secure=False, useragent=None):
724 """
725 TODO: Constructor
726
727 @param username: User name. String
728 @param passwd: Password. String
729 @param client_obj: omero.client
730 @param group: admin group
731 @param clone: Boolean
732 @param try_super: Boolean
733 @param host: Omero server host. String
734 @param port: Omero server port. Integer
735 @param extra_config:
736 @param secure: Initial underlying omero.client connection type (True=SSL/False=insecure)
737 """
738
739 super(_BlitzGateway, self).__init__()
740 self.client = client_obj
741 if not type(extra_config) in (type(()), type([])):
742 extra_config=[extra_config]
743 self.extra_config = extra_config
744 self.ice_config = [self.ICE_CONFIG]
745 self.ice_config.extend(extra_config)
746 self.ice_config = map(lambda x: str(x), filter(None, self.ice_config))
747
748 self.host = host
749 self.port = port
750 self.secure = secure
751 self.useragent = useragent
752
753 self._resetOmeroClient()
754 if not username:
755 username = self.c.ic.getProperties().getProperty('omero.gateway.anon_user')
756 passwd = self.c.ic.getProperties().getProperty('omero.gateway.anon_pass')
757
758 if try_super:
759 self.group = 'system'
760 else:
761 self.group = group and group or None
762 self._sessionUuid = None
763 self._session_cb = None
764 self._session = None
765 self._lastGroupId = None
766 self._anonymous = True
767
768
769 self.setIdentity(username, passwd, not clone)
770
771 self._connected = False
772 self._user = None
773 self._userid = None
774 self._proxies = NoProxies()
775
778
780 return self.__class__(self._ic_props[omero.constants.USERNAME],
781 self._ic_props[omero.constants.PASSWORD],
782 host = self.host,
783 port = self.port,
784 extra_config=self.extra_config,
785 clone=True,
786 secure=self.secure)
787
788
789 - def setIdentity (self, username, passwd, _internal=False):
790 """
791 TODO: description
792
793 @param username: User name. String
794 @param passwd: Password. String
795 @param _internal: Boolean
796 """
797
798 self._ic_props = {omero.constants.USERNAME: username,
799 omero.constants.PASSWORD: passwd}
800 self._anonymous = _internal
801
802 - def suConn (self, username, group=None, ttl=60000):
818
820 """
821 Keeps service alive.
822 Returns True if connected. If connection was lost, reconnecting.
823
824 @return: Boolean
825 """
826
827 try:
828 if self.c.sf is None:
829 logger.debug('... c.sf is None, reconnecting')
830 return self.connect()
831 return self.c.sf.keepAlive(self._proxies['admin']._obj)
832 except Ice.ObjectNotExistException:
833
834 logger.debug(traceback.format_exc())
835 logger.debug("... reset, not reconnecting")
836 return False
837 except Ice.ConnectionLostException:
838
839 logger.debug(traceback.format_exc())
840 logger.debug("... lost, reconnecting")
841
842 return False
843 except Ice.ConnectionRefusedException:
844
845 logger.debug(traceback.format_exc())
846 logger.debug("... refused, not reconnecting")
847 return False
848 except omero.SessionTimeoutException:
849
850 logger.debug(traceback.format_exc())
851 logger.debug("... reset, not reconnecting")
852 return False
853 except omero.RemovedSessionException:
854
855 logger.debug(traceback.format_exc())
856 logger.debug("... session has left the building, not reconnecting")
857 return False
858 except Ice.UnknownException, x:
859
860 logger.debug(traceback.format_exc())
861 logger.debug('Ice.UnknownException: %s' % str(x))
862 logger.debug("... ice says something bad happened, not reconnecting")
863 return False
864 except:
865
866 logger.debug(traceback.format_exc())
867 logger.debug("... error not reconnecting")
868 return False
869
870 - def seppuku (self, softclose=False):
871 """
872 Terminates connection. If softclose is False, the session is really
873 terminate disregarding its connection refcount.
874
875 @param softclose: Boolean
876 """
877
878 self._connected = False
879 if self.c:
880 try:
881 self.c.sf.closeOnDestroy()
882 except:
883 pass
884 try:
885 if softclose:
886 try:
887 r = self.c.sf.getSessionService().getReferenceCount(self._sessionUuid)
888 self.c.closeSession()
889 if r < 2:
890 self._session_cb and self._session_cb.close(self)
891 except Ice.OperationNotExistException:
892 self.c.closeSession()
893 else:
894 self._closeSession()
895 except:
896 pass
897 self.c = None
898 self._proxies = NoProxies()
899 logger.info("closed connecion (uuid=%s)" % str(self._sessionUuid))
900
902 logger.debug("##GARBAGE COLLECTOR KICK IN")
903
905 """
906 Creates proxies to the server services.
907 """
908
909 if not isinstance(self._proxies, NoProxies):
910 logger.debug("## Reusing proxies")
911 for k, p in self._proxies.items():
912 p._resyncConn(self)
913 else:
914 logger.debug("## Creating proxies")
915 self._proxies = {}
916 self._proxies['admin'] = ProxyObjectWrapper(self, 'getAdminService')
917 self._proxies['config'] = ProxyObjectWrapper(self, 'getConfigService')
918 self._proxies['container'] = ProxyObjectWrapper(self, 'getContainerService')
919 self._proxies['delete'] = ProxyObjectWrapper(self, 'getDeleteService')
920 self._proxies['export'] = ProxyObjectWrapper(self, 'createExporter')
921 self._proxies['ldap'] = ProxyObjectWrapper(self, 'getLdapService')
922 self._proxies['metadata'] = ProxyObjectWrapper(self, 'getMetadataService')
923 self._proxies['query'] = ProxyObjectWrapper(self, 'getQueryService')
924 self._proxies['pixel'] = ProxyObjectWrapper(self, 'getPixelsService')
925 self._proxies['projection'] = ProxyObjectWrapper(self, 'getProjectionService')
926 self._proxies['rawpixels'] = ProxyObjectWrapper(self, 'createRawPixelsStore')
927 self._proxies['rendering'] = ProxyObjectWrapper(self, 'createRenderingEngine')
928 self._proxies['rendsettings'] = ProxyObjectWrapper(self, 'getRenderingSettingsService')
929 self._proxies['rawfile'] = ProxyObjectWrapper(self, 'createRawFileStore')
930 self._proxies['repository'] = ProxyObjectWrapper(self, 'getRepositoryInfoService')
931 self._proxies['roi'] = ProxyObjectWrapper(self, 'getRoiService')
932 self._proxies['script'] = ProxyObjectWrapper(self, 'getScriptService')
933 self._proxies['search'] = ProxyObjectWrapper(self, 'createSearchService')
934 self._proxies['session'] = ProxyObjectWrapper(self, 'getSessionService')
935 self._proxies['share'] = ProxyObjectWrapper(self, 'getShareService')
936 self._proxies['thumbs'] = ProxyObjectWrapper(self, 'createThumbnailStore')
937 self._proxies['timeline'] = ProxyObjectWrapper(self, 'getTimelineService')
938 self._proxies['types'] = ProxyObjectWrapper(self, 'getTypesService')
939 self._proxies['update'] = ProxyObjectWrapper(self, 'getUpdateService')
940
941 self._ctx = self._proxies['admin'].getEventContext()
942 if self._ctx is not None:
943 self._userid = self._ctx.userId
944
945 self._user = self._ctx.userName!="guest" and self.getExperimenter(self._userid) or None
946 else:
947 self._userid = None
948 self._user = None
949
950 if self._session_cb:
951 if self._was_join:
952 self._session_cb.join(self)
953 else:
954 self._session_cb.create(self)
955
957 """ Switches between SSL and insecure (faster) connections to Blitz.
958 The gateway must already be connected. """
959 if hasattr(self.c, 'createClient') and (secure ^ self.c.isSecure()):
960 self.c = self.c.createClient(secure=secure)
961 self._createProxies()
962 self.secure = secure
963
965 """ Returns 'True' if the underlying omero.clients.BaseClient is connected using SSL """
966 return hasattr(self.c, 'isSecure') and self.c.isSecure() or False
967
984
986 """
987 Close session.
988 """
989
990 self._session_cb and self._session_cb.close(self)
991 if self._sessionUuid:
992 s = omero.model.SessionI()
993 s._uuid = omero_type(self._sessionUuid)
994 try:
995
996
997
998
999
1000 self.c.killSession()
1001 except Ice.ObjectNotExistException:
1002 pass
1003 except omero.RemovedSessionException:
1004 pass
1005 except ValueError:
1006 raise
1007 except:
1008 logger.warn(traceback.format_exc())
1009 else:
1010 try:
1011 self.c.killSession()
1012 except Glacier2.SessionNotExistException:
1013 pass
1014 except:
1015 logger.warn(traceback.format_exc())
1016
1018 """
1019 Resets omero.client object.
1020 """
1021
1022 if self.host is not None:
1023 self.c = omero.client(host=str(self.host), port=int(self.port))
1024 else:
1025 self.c = omero.client(pmap=['--Ice.Config='+','.join(self.ice_config)])
1026
1027 if hasattr(self.c, "setAgent"):
1028 if self.useragent is not None:
1029 self.c.setAgent(self.useragent)
1030 else:
1031 self.c.setAgent("OMERO.py.gateway")
1032
1034 """
1035 Creates or retrieves connection for the given sessionUuid.
1036 Returns True if connected.
1037
1038 @param sUuid: omero_model_SessionI
1039 @return: Boolean
1040 """
1041
1042 logger.debug("Connect attempt, sUuid=%s, group=%s, self.sUuid=%s" % (str(sUuid), str(self.group), self._sessionUuid))
1043 if not self.c:
1044 self._connected = False
1045 logger.debug("Ooops. no self._c")
1046 return False
1047 try:
1048 if self._sessionUuid is None and sUuid:
1049 self._sessionUuid = sUuid
1050 if self._sessionUuid is not None:
1051 try:
1052 logger.debug('connected? %s' % str(self._connected))
1053 if self._connected:
1054 self._connected = False
1055 logger.debug("was connected, creating new omero.client")
1056 self._resetOmeroClient()
1057 s = self.c.joinSession(self._sessionUuid)
1058 s.detachOnDestroy()
1059 logger.debug('joinSession(%s)' % self._sessionUuid)
1060 self._was_join = True
1061 except Ice.SyscallException:
1062 raise
1063 except Exception, x:
1064 logger.debug("Error: " + str(x))
1065 self._sessionUuid = None
1066 if sUuid:
1067 return False
1068 if self._sessionUuid is None:
1069 if sUuid:
1070 logger.debug("Uncaptured sUuid failure!")
1071 if self._connected:
1072 self._connected = False
1073 try:
1074
1075
1076 self._closeSession()
1077 self._resetOmeroClient()
1078
1079 except Glacier2.SessionNotExistException:
1080 pass
1081 setprop = self.c.ic.getProperties().setProperty
1082 map(lambda x: setprop(x[0],str(x[1])), self._ic_props.items())
1083 if self._anonymous:
1084 self.c.ic.getImplicitContext().put(omero.constants.EVENT, 'Internal')
1085 if self.group is not None:
1086 self.c.ic.getImplicitContext().put(omero.constants.GROUP, self.group)
1087 try:
1088 self._createSession()
1089 except omero.SecurityViolation:
1090 if self.group is not None:
1091
1092 logger.debug("## User not in '%s' group" % self.group)
1093 self.group = None
1094 self._closeSession()
1095 self._sessionUuid = None
1096 self._connected=True
1097 return self.connect()
1098 else:
1099 logger.debug("BlitzGateway.connect().createSession(): " + traceback.format_exc())
1100 logger.info('first create session threw SecurityViolation, hold off 10 secs and retry (but only once)')
1101
1102 try:
1103 self._createSession()
1104 except omero.SecurityViolation:
1105 if self.group is not None:
1106
1107 logger.debug("## User not in '%s' group" % self.group)
1108 self.group = None
1109 self._connected=True
1110 return self.connect()
1111 else:
1112 raise
1113 except Ice.SyscallException:
1114 raise
1115 except:
1116 logger.info("BlitzGateway.connect().createSession(): " + traceback.format_exc())
1117 logger.debug(str(self._ic_props))
1118
1119 self._createSession()
1120
1121 self._last_error = None
1122 self._createProxies()
1123 self._connected = True
1124 logger.info('created connection (uuid=%s)' % str(self._sessionUuid))
1125 except Ice.SyscallException:
1126 logger.debug('This one is a SyscallException')
1127 raise
1128 except Ice.LocalException, x:
1129 logger.debug("connect(): " + traceback.format_exc())
1130 self._last_error = x
1131 return False
1132 except Exception, x:
1133 logger.debug("connect(): " + traceback.format_exc())
1134 self._last_error = x
1135 return False
1136 logger.debug(".. connected!")
1137 return True
1138
1140 """
1141 Returns error if thrown by _BlitzGateway.connect connect.
1142
1143 @return: String
1144 """
1145
1146 return self._last_error
1147
1149 """
1150 Returns last status of connection.
1151
1152 @return: Boolean
1153 """
1154
1155 return self._connected
1156
1157
1158
1159
1160 - def getEventContext (self):
1161 """
1162 Returns omero_System_ice.EventContext.
1163 It containes::
1164 shareId, sessionId, sessionUuid, userId, userName,
1165 groupId, groupName, isAdmin, isReadOnly,
1166 eventId, eventType, eventType,
1167 memberOfGroups, leaderOfGroups
1168
1169 @return: omero.sys.EventContext
1170 """
1171
1172 self._ctx = self._proxies['admin'].getEventContext()
1173 return self._ctx
1174
1176 """
1177 Returns current omero_model_ExperimenterI.
1178
1179 @return: omero.model.ExperimenterI
1180 """
1181
1182 return self._user
1183
1185 """
1186 Returns current omero_model_ExperimenterGroupI.
1187
1188 @return: omero.model.ExperimenterGroupI
1189 """
1190
1191 admin_service = self.getAdminService()
1192 group = admin_service.getGroup(self.getEventContext().groupId)
1193 return ExperimenterGroupWrapper(self, group)
1194
1196 """
1197 Checks if a user has administration privileges.
1198
1199 @return: Boolean
1200 """
1201
1202 return self.getEventContext().isAdmin
1203
1205 """
1206 Checks if a user is in system group, i.e. can have administration privileges.
1207
1208 @return: Boolean
1209 """
1210 return 0 in self.getEventContext().memberOfGroups
1211
1213 """
1214 Checks if a user has owner privileges.
1215
1216 @return: Boolean
1217 """
1218 if not isinstance(gid, LongType) or not isinstance(gid, IntType):
1219 gid = long(gid)
1220 if gid is not None:
1221 for gem in self._user.copyGroupExperimenterMap():
1222 if gem.parent.id.val == gid and gem.owner.val == True:
1223 return True
1224 else:
1225 for gem in self._user.copyGroupExperimenterMap():
1226 if gem.owner.val == True:
1227 return True
1228 return False
1229
1231 """
1232 Checks if a user has write privileges to the given object.
1233
1234 @param obj: Given object
1235 @return: Boolean
1236 """
1237
1238 return self.isAdmin() or (self._userid == obj.details.owner.id.val and obj.details.permissions.isUserWrite())
1239
1241 if self._session is None:
1242 ss = self.c.sf.getSessionService()
1243 self._session = ss.getSession(self._sessionUuid)
1244 return self._session
1245
1246
1247
1248
1249
1250
1251
1256
1258 if self.getEventContext().groupId == groupid:
1259 return True
1260 if groupid not in self._ctx.memberOfGroups:
1261 return False
1262 self._lastGroupId = self._ctx.groupId
1263 if hasattr(self.c, 'setSecurityContext'):
1264
1265 self.c.sf.setSecurityContext(omero.model.ExperimenterGroupI(groupid, False))
1266 else:
1267 self.getSession()
1268 self._session.getDetails().setGroup(omero.model.ExperimenterGroupI(groupid, False))
1269 self._session.setTimeToIdle(None)
1270 self.getSessionService().updateSession(self._session)
1271 return True
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1289 if self._lastGroupId is not None:
1290 self.setGroupForSession(self._lastGroupId)
1291 self._lastGroupId = None
1292
1293
1294
1295
1297 """
1298 Gets reference to the admin service from ProxyObjectWrapper.
1299
1300 @return: omero.gateway.ProxyObjectWrapper
1301 """
1302
1303 return self._proxies['admin']
1304
1306 """
1307 Gets reference to the query service from ProxyObjectWrapper.
1308
1309 @return: omero.gateway.ProxyObjectWrapper
1310 """
1311 return self._proxies['query']
1312
1314 """
1315 Gets reference to the container service from ProxyObjectWrapper.
1316
1317 @return: omero.gateway.ProxyObjectWrapper
1318 """
1319
1320 return self._proxies['container']
1321
1323 """
1324 Gets reference to the pixels service from ProxyObjectWrapper.
1325
1326 @return: omero.gateway.ProxyObjectWrapper
1327 """
1328
1329 return self._proxies['pixel']
1330
1339
1341 """
1342 Gets ROI service.
1343
1344 @return: omero.gateway.ProxyObjectWrapper
1345 """
1346
1347 return self._proxies['roi']
1348
1350 """
1351 Gets script service.
1352
1353 @return: omero.gateway.ProxyObjectWrapper
1354 """
1355
1356 return self._proxies['script']
1357
1359 """
1360 Creates a new raw file store.
1361 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1362 returns a new object, avoiding unexpected inherited states.
1363
1364 @return: omero.gateway.ProxyObjectWrapper
1365 """
1366
1367 return self._proxies['rawfile']
1368
1370 """
1371 Gets reference to the repository info service from ProxyObjectWrapper.
1372
1373 @return: omero.gateway.ProxyObjectWrapper
1374 """
1375
1376 return self._proxies['repository']
1377
1379 """
1380 Gets reference to the share service from ProxyObjectWrapper.
1381
1382 @return: omero.gateway.ProxyObjectWrapper
1383 """
1384
1385 return self._proxies['share']
1386
1388 """
1389 Gets reference to the timeline service from ProxyObjectWrapper.
1390
1391 @return: omero.gateway.ProxyObjectWrapper
1392 """
1393
1394 return self._proxies['timeline']
1395
1397 """
1398 Gets reference to the types service from ProxyObjectWrapper.
1399
1400 @return: omero.gateway.ProxyObjectWrapper
1401 """
1402
1403 return self._proxies['types']
1404
1406 """
1407 Gets reference to the config service from ProxyObjectWrapper.
1408
1409 @return: omero.gateway.ProxyObjectWrapper
1410 """
1411
1412 return self._proxies['config']
1413
1415 """
1416 Creates a new rendering engine.
1417 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1418 returns a new object, avoiding unexpected inherited states.
1419
1420 @return: omero.gateway.ProxyObjectWrapper
1421 """
1422
1423 rv = self._proxies['rendering']
1424 if rv._tainted:
1425 rv = self._proxies['rendering'] = rv.clone()
1426 rv.taint()
1427 return rv
1428
1430 """
1431 Gets reference to the rendering settings service from ProxyObjectWrapper.
1432
1433 @return: omero.gateway.ProxyObjectWrapper
1434 """
1435
1436 return self._proxies['rendsettings']
1437
1439 """
1440 Creates a new raw pixels store.
1441 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1442 returns a new object, avoiding unexpected inherited states.
1443
1444 @return: omero.gateway.ProxyObjectWrapper
1445 """
1446
1447 return self._proxies['rawpixels']
1448
1450 """
1451 Gets a reference to the thumbnail store on this connection object or creates a new one
1452 if none exists.
1453
1454 @rtype: omero.gateway.ProxyObjectWrapper
1455 @return: The proxy wrapper of the thumbnail store
1456 """
1457
1458 return self._proxies['thumbs']
1459
1461 """
1462 Creates a new search service.
1463 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1464 returns a new object, avoiding unexpected inherited states.
1465
1466 @return: omero.gateway.ProxyObjectWrapper
1467 """
1468 return self._proxies['search']
1469
1471 """
1472 Gets reference to the update service from ProxyObjectWrapper.
1473
1474 @return: omero.gateway.ProxyObjectWrapper
1475 """
1476 return self._proxies['update']
1477
1479 """
1480 Gets reference to the delete service from ProxyObjectWrapper.
1481
1482 @return: omero.gateway.ProxyObjectWrapper
1483 """
1484 return self._proxies['delete']
1485
1487 """
1488 Gets reference to the session service from ProxyObjectWrapper.
1489
1490 @return: omero.gateway.ProxyObjectWrapper
1491 """
1492 return self._proxies['session']
1493
1495 """
1496 New instance of non cached Exporter, wrapped in ProxyObjectWrapper.
1497
1498 @return: omero.gateway.ProxyObjectWrapper
1499 """
1500
1501 return self._proxies['export']
1502
1503
1504
1505
1507 """
1508 List every Projects controlled by the security system.
1509
1510 @param only_owned: Only owned by the logged user. Boolean.
1511 @return: Generator yielding _ProjectWrapper
1512 """
1513
1514 q = self.getQueryService()
1515 cache = {}
1516 if only_owned:
1517 params = omero.sys.Parameters()
1518 params.map = {'owner_id': rlong(self._userid)}
1519 for e in q.findAllByQuery("from Project as p where p.details.owner.id=:owner_id order by p.name", params):
1520 yield ProjectWrapper(self, e, cache)
1521 else:
1522 for e in q.findAll('Project', None):
1523 yield ProjectWrapper(self, e, cache)
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1538 """ Fetch an Group and all contained users."""
1539
1540 admin_service = self.getAdminService()
1541 group = admin_service.getGroup(long(gid))
1542 return ExperimenterGroupWrapper(self, group)
1543
1545 """ Look up an Group and all contained users by name."""
1546
1547 admin_service = self.getAdminService()
1548 group = admin_service.lookupGroup(str(name))
1549 return ExperimenterGroupWrapper(self, group)
1550
1552 """ Retrieve the default group for the given user id."""
1553
1554 admin_serv = self.getAdminService()
1555 dgr = admin_serv.getDefaultGroup(long(eid))
1556 return ExperimenterGroupWrapper(self, dgr)
1557
1559 """ Fetch all groups of which the given user is a member.
1560 The returned groups will have all fields filled in and all collections unloaded."""
1561
1562 admin_serv = self.getAdminService()
1563 for gr in admin_serv.containedGroups(long(eid)):
1564 yield ExperimenterGroupWrapper(self, gr)
1565
1567 """ Look up Groups where current user is a leader of."""
1568
1569 q = self.getQueryService()
1570 p = omero.sys.Parameters()
1571 p.map = {}
1572 p.map["ids"] = rlist([rlong(a) for a in self.getEventContext().leaderOfGroups])
1573 sql = "select e from ExperimenterGroup as e where e.id in (:ids)"
1574 for e in q.findAllByQuery(sql, p):
1575 yield ExperimenterGroupWrapper(self, e)
1576
1578 """ Look up Groups where current user is a member of (except "user")."""
1579
1580 q = self.getQueryService()
1581 p = omero.sys.Parameters()
1582 p.map = {}
1583 p.map["ids"] = rlist([rlong(a) for a in self.getEventContext().memberOfGroups])
1584 sql = "select e from ExperimenterGroup as e where e.id in (:ids)"
1585 for e in q.findAllByQuery(sql, p):
1586 if e.name.val == "user":
1587 pass
1588 else:
1589 yield ExperimenterGroupWrapper(self, e)
1590
1591
1592
1594 """ Look up all experimenters all related groups.
1595 The experimenters are also loaded."""
1596
1597 admin_serv = self.getAdminService()
1598 for exp in admin_serv.lookupExperimenters():
1599 yield ExperimenterWrapper(self, exp)
1600
1602 """
1603 Return an Experimenter for the given ID.
1604
1605 @param eid: User ID.
1606 @return: _ExperimenterWrapper or None
1607 """
1608
1609 admin_serv = self.getAdminService()
1610 try:
1611 exp = admin_serv.getExperimenter(long(eid))
1612 return ExperimenterWrapper(self, exp)
1613 except omero.ApiUsageException:
1614 return None
1615
1617 """
1618 Return an Experimenter for the given username.
1619
1620 @param name: Username. String
1621 @return: _ExperimenterWrapper or None
1622 """
1623
1624 admin_serv = self.getAdminService()
1625 try:
1626 exp = admin_serv.lookupExperimenter(str(name))
1627 return ExperimenterWrapper(self, exp)
1628 except omero.ApiUsageException:
1629 return None
1630
1632 """ Fetch all users contained in this group.
1633 The returned users will have all fields filled in and all collections unloaded."""
1634
1635 admin_serv = self.getAdminService()
1636 for exp in admin_serv.containedExperimenters(long(gid)):
1637 yield ExperimenterWrapper(self, exp)
1638
1647
1649 """ Look up users who are a member of the group owned by the current user."""
1650
1651 q = self.getQueryService()
1652 gr_list = self.getEventContext().leaderOfGroups
1653 p = omero.sys.Parameters()
1654 p.map = {}
1655 p.map["gids"] = rlist([rlong(a) for a in set(gr_list)])
1656 sql = "select e from Experimenter as e where " \
1657 "exists ( select gem from GroupExperimenterMap as gem where gem.child = e.id and gem.parent.id in (:gids)) order by e.omeName"
1658 for e in q.findAllByQuery(sql, p):
1659 if e.id.val != self.getEventContext().userId:
1660 yield ExperimenterWrapper(self, e)
1661
1663 """ Look up users who are a member of the current user active group
1664 and users who are a member of the group owned by the current user."""
1665
1666
1667 q = self.getQueryService()
1668 gr_list = list()
1669 gr_list.extend(self.getEventContext().memberOfGroups)
1670 gr_list.extend(self.getEventContext().leaderOfGroups)
1671 p = omero.sys.Parameters()
1672 p.map = {}
1673 p.map["gids"] = rlist([rlong(a) for a in set(gr_list)])
1674 sql = "select e from Experimenter as e where " \
1675 "exists ( select gem from GroupExperimenterMap as gem where gem.child = e.id and gem.parent.id in (:gids)) order by e.omeName"
1676 for e in q.findAllByQuery(sql, p):
1677 if e.id.val != self.getEventContext().userId:
1678 yield ExperimenterWrapper(self, e)
1679
1681 """ Looks up all groups and all related experimenters.
1682 The experimenters' groups are also loaded."""
1683
1684 admin_serv = self.getAdminService()
1685 for gr in admin_serv.lookupGroups():
1686 yield ExperimenterGroupWrapper(self, gr)
1687
1689 """ Looks up owned groups for the logged user. """
1690
1691 exp = self.getUser()
1692 for gem in exp.copyGroupExperimenterMap():
1693 if gem.owner.val:
1694 yield ExperimenterGroupWrapper(self, gem.parent)
1695
1696
1698 """ Returns the free or available space on this file system
1699 including nested subdirectories. """
1700
1701 rep_serv = self.getRepositoryInfoService()
1702 return rep_serv.getFreeSpaceInKilobytes() * 1024
1703
1704
1705
1706
1708 """ Gets all owned shares for the current user. """
1709
1710 sh = self.getShareService()
1711 for e in sh.getOwnShares(False):
1712 yield ShareWrapper(self, e)
1713
1715 """ Gets all shares where current user is a member. """
1716
1717 sh = self.getShareService()
1718 for e in sh.getMemberShares(False):
1719 yield ShareWrapper(self, e)
1720
1722 """ Returns a map from share id to the count of total members (including the
1723 owner). This is represented by ome.model.meta.ShareMember links."""
1724
1725 sh = self.getShareService()
1726 return sh.getMemberCount(share_ids)
1727
1733
1734 - def getContents(self, share_id):
1735 """ Looks up all items belong to the share."""
1736
1737 sh = self.getShareService()
1738 for e in sh.getContents(long(share_id)):
1739 yield ShareContentWrapper(self, e)
1740
1747
1749 """ Get all {@link Experimenter users} who are a member of the share."""
1750
1751 sh = self.getShareService()
1752 for e in sh.getAllMembers(long(share_id)):
1753 yield ExperimenterWrapper(self, e)
1754
1756 """ Get the email addresses for all share guests."""
1757
1758 sh = self.getShareService()
1759 return sh.getAllGuests(long(share_id))
1760
1762 """ Get a single set containing the login names of the users as well email addresses for guests."""
1763
1764 sh = self.getShareService()
1765 return sh.getAllUsers(long(share_id))
1766
1767
1768
1769
1771 """
1772 List images based on the their creation times.
1773 If both tfrom and tto are None, grab the most recent batch.
1774
1775 @param tfrom: milliseconds since the epoch for start date
1776 @param tto: milliseconds since the epoch for end date
1777 @param tlimit: maximum number of results
1778 @param only_owned: Only owned by the logged user. Boolean.
1779 @return: Generator yielding _ImageWrapper
1780 """
1781 tm = self.getTimelineService()
1782 p = omero.sys.Parameters()
1783 f = omero.sys.Filter()
1784 if only_owned:
1785 f.ownerId = rlong(self.getEventContext().userId)
1786 f.groupId = rlong(self.getEventContext().groupId)
1787 else:
1788 f.ownerId = rlong(-1)
1789 f.groupId = None
1790 f.limit = rint(limit)
1791 p.theFilter = f
1792 if tfrom is None and tto is None:
1793 for e in tm.getMostRecentObjects(['Image'], p, False)["Image"]:
1794 yield ImageWrapper(self, e)
1795 else:
1796 if tfrom is None:
1797 tfrom = 0
1798 if tto is None:
1799 tto = time.time() * 1000
1800 for e in tm.getByPeriod(['Image'], rtime(long(tfrom)), rtime(long(tto)), p, False)['Image']:
1801 yield ImageWrapper(self, e)
1802
1803
1804
1805
1806
1808 """
1809 Return Project for the given ID.
1810
1811 @param oid: Project ID.
1812 @return: _ProjectWrapper or None
1813 """
1814
1815 q = self.getQueryService()
1816 pr = q.find("Project", long(oid))
1817 if pr is not None:
1818 pr = ProjectWrapper(self, pr)
1819 return pr
1820
1822 """
1823 Return Project with the given name.
1824
1825 @param name: Project name.
1826 @return: _ProjectWrapper or None
1827 """
1828 q = self.getQueryService()
1829 params = omero.sys.Parameters()
1830 if not params.map:
1831 params.map = {}
1832 params.map['name'] = rstring(name)
1833 pr = q.findAllByQuery("from Project as p where p.name=:name", params)
1834 if len(pr):
1835 return ProjectWrapper(self, pr[0])
1836 return None
1837
1839 """
1840 Return Dataset for the given ID.
1841
1842 @param oid: Dataset ID.
1843 @return: _DatasetWrapper or None
1844 """
1845
1846 q = self.getQueryService()
1847 ds = q.find("Dataset", long(oid))
1848 if ds is not None:
1849 ds = DatasetWrapper(self, ds)
1850 return ds
1851
1853 """
1854 Return Image for the given ID.
1855
1856 @param oid: Image ID.
1857 @return: _ImageWrapper or None
1858 """
1859
1860 q = self.getQueryService()
1861 img = q.find("Image", long(oid))
1862 if img is not None:
1863 img = ImageWrapper(self, img)
1864 return img
1865
1867 """ Gets share for the given share id. """
1868
1869 sh_serv = self.getShareService()
1870 sh = sh_serv.getShare(long(oid))
1871 if sh is not None:
1872 return ShareWrapper(self, sh)
1873 else:
1874 return None
1875
1877 query_serv = self.getQueryService()
1878 p = omero.sys.Parameters()
1879 p.map = {}
1880 p.map["oid"] = rlong(long(oid))
1881 sql = "select sc from Screen sc join fetch sc.details.owner join fetch sc.details.group where sc.id=:oid "
1882 sc = query_serv.findByQuery(sql,p)
1883 if sc is not None:
1884 return ScreenWrapper(self, sc)
1885 else:
1886 return None
1887
1889 query_serv = self.getQueryService()
1890 p = omero.sys.Parameters()
1891 p.map = {}
1892 p.map["oid"] = rlong(long(oid))
1893 sql = "select pl from Plate pl join fetch pl.details.owner join fetch pl.details.group " \
1894 "left outer join fetch pl.screenLinks spl " \
1895 "left outer join fetch spl.parent sc where pl.id=:oid "
1896 pl = query_serv.findByQuery(sql,p)
1897 if pl is not None:
1898 return PlateWrapper(self, pl)
1899 else:
1900 return None
1901
1903 query_serv = self.getQueryService()
1904 p = omero.sys.Parameters()
1905 p.map = {}
1906 p.map["ids"] = rlist([rlong(a) for a in oids])
1907 sql = "select im from Image im join fetch im.details.owner join fetch im.details.group where im.id in (:ids) order by im.name"
1908 for e in query_serv.findAllByQuery(sql, p):
1909 yield ImageWrapper(self, e)
1910
1912 query_serv = self.getQueryService()
1913 p = omero.sys.Parameters()
1914 p.map = {}
1915 p.map["ids"] = rlist([rlong(a) for a in oids])
1916 sql = "select ds from Dataset ds join fetch ds.details.owner join fetch ds.details.group where ds.id in (:ids) order by ds.name"
1917 for e in query_serv.findAllByQuery(sql, p):
1918 yield DatasetWrapper(self, e)
1919
1921 query_serv = self.getQueryService()
1922 p = omero.sys.Parameters()
1923 p.map = {}
1924 p.map["ids"] = rlist([rlong(a) for a in oids])
1925 sql = "select pr from Project pr join fetch pr.details.owner join fetch pr.details.group where pr.id in (:ids) order by pr.name"
1926 for e in query_serv.findAllByQuery(sql, p):
1927 yield ProjectWrapper(self, e)
1928
1930 query_serv = self.getQueryService()
1931 p = omero.sys.Parameters()
1932 p.map = {}
1933 p.map["ids"] = rlist([rlong(a) for a in oids])
1934 sql = "select pl from Plate pl join fetch pl.details.owner join fetch pl.details.group where pl.id in (:ids) order by pl.name"
1935 for e in query_serv.findAllByQuery(sql, p):
1936 yield DatasetWrapper(self, e)
1937
1938
1939
1940
1942 query_serv = self.getQueryService()
1943 p = omero.sys.Parameters()
1944 p.map = {}
1945 p.map["oid"] = rlong(long(oid))
1946 sql = "select f from FileAnnotation f join fetch f.file where f.id = :oid"
1947 of = query_serv.findByQuery(sql, p)
1948 return FileAnnotationWrapper(self, of)
1949
1958
1960 query_serv = self.getQueryService()
1961 p = omero.sys.Parameters()
1962 p.map = {}
1963 p.map["oid"] = rlong(long(oid))
1964 sql = "select tg from TagAnnotation tg where tg.id = :oid"
1965 tg = query_serv.findByQuery(sql, p)
1966 return AnnotationWrapper(self, tg)
1967
1969 query_serv = self.getQueryService()
1970 p = omero.sys.Parameters()
1971 p.map = {}
1972 p.map["text"] = rstring(str(name))
1973 p.map["eid"] = rlong(self.getEventContext().userId)
1974 f = omero.sys.Filter()
1975 f.limit = rint(1)
1976 p.theFilter = f
1977 sql = "select tg from TagAnnotation tg " \
1978 "where tg.textValue=:text and tg.details.owner.id=:eid and tg.ns is null order by tg.textValue"
1979 tg = query_serv.findByQuery(sql, p)
1980 return AnnotationWrapper(self, tg)
1981
1982
1983
1984
1986 """
1987 TODO: description
1988
1989 @return: Generator yielding _ImageWrapper
1990 """
1991
1992 if not params:
1993 params = omero.sys.Parameters()
1994 if not params.map:
1995 params.map = {}
1996 params.map["ns"] = omero_type(ns)
1997 query = """
1998 select i
1999 from Image i
2000 join i.annotationLinks ial
2001 join ial.child as a
2002 where a.ns = :ns
2003 order by a.id desc """
2004 for i in self.getQueryService().findAllByQuery(query, params):
2005 yield ImageWrapper(self, i)
2006
2007
2008
2009
2010
2012 types = self.getTypesService()
2013 for e in types.allEnumerations(str(klass)):
2014 yield EnumerationWrapper(self, e)
2015
2017 types = self.getTypesService()
2018 obj = types.getEnumeration(str(klass), str(string))
2019 if obj is not None:
2020 return EnumerationWrapper(self, obj)
2021 else:
2022 return None
2023
2025 query_serv = self.getQueryService()
2026 obj = query_serv.find(klass, long(eid))
2027 if obj is not None:
2028 return EnumerationWrapper(self, obj)
2029 else:
2030 return None
2031
2040
2042 types = self.getTypesService()
2043 return types.getEnumerationTypes()
2044
2054
2058
2062
2066
2070
2071
2072
2073
2077
2083
2085 op = dict()
2086 if anns is None:
2087 op["/TagAnnotation"] = "KEEP"
2088 op["/TermAnnotation"] = "KEEP"
2089 op["/FileAnnotation"] = "KEEP"
2090 dc = omero.api.delete.DeleteCommand('/Image', long(oid), op)
2091 handle = self.getDeleteService().queueDelete([dc])
2092 return handle
2093
2095 op = dict()
2096 if anns is None:
2097 op["/TagAnnotation"] = "KEEP"
2098 op["/TermAnnotation"] = "KEEP"
2099 op["/FileAnnotation"] = "KEEP"
2100 dcs = list()
2101 for i in ids:
2102 dcs.append(omero.api.delete.DeleteCommand('/Image', long(i), op))
2103 handle = self.getDeleteService().queueDelete(dcs)
2104 return handle
2105
2107 op = dict()
2108 if anns is None:
2109 op["/TagAnnotation"] = "KEEP"
2110 op["/TermAnnotation"] = "KEEP"
2111 op["/FileAnnotation"] = "KEEP"
2112 dc = omero.api.delete.DeleteCommand('/Plate', long(oid), op)
2113 handle = self.getDeleteService().queueDelete([dc])
2114 return handle
2115
2117 op = dict()
2118 if anns is None:
2119 op["/TagAnnotation"] = "KEEP"
2120 op["/TermAnnotation"] = "KEEP"
2121 op["/FileAnnotation"] = "KEEP"
2122 if child is None:
2123 op["/Image"] = "KEEP"
2124 dc = omero.api.delete.DeleteCommand('/Dataset', long(obj.id), op)
2125 handle = self.getDeleteService().queueDelete([dc])
2126 return handle
2127
2129 op = dict()
2130 if anns is None:
2131 op["/TagAnnotation"] = "KEEP"
2132 op["/TermAnnotation"] = "KEEP"
2133 op["/FileAnnotation"] = "KEEP"
2134 if child is None:
2135 op["/Dataset"] = "KEEP"
2136 op["/Image"] = "KEEP"
2137 dc = omero.api.delete.DeleteCommand('/Project', long(obj.id), op)
2138 handle = self.getDeleteService().queueDelete([dc])
2139 return handle
2140
2142 op = dict()
2143 if anns is None:
2144 op["/TagAnnotation"] = "KEEP"
2145 op["/TermAnnotation"] = "KEEP"
2146 op["/FileAnnotation"] = "KEEP"
2147 if child is None:
2148 op["/Plate"] = "KEEP"
2149 dc = omero.api.delete.DeleteCommand('/Screen', long(obj.id), op)
2150 handle = self.getDeleteService().queueDelete([dc])
2151 return handle
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2164 search = self.createSearchService()
2165 search.onlyType('Image')
2166 search.addOrderByAsc("name")
2167 if created:
2168 search.onlyCreatedBetween(created[0], created[1]);
2169 if text:
2170 search.setAllowLeadingWildcard(True)
2171 search.byFullText(str(text))
2172 if search.hasNext():
2173 for e in search.results():
2174 yield ImageWrapper(self, e)
2175
2177 search = self.createSearchService()
2178 search.onlyType('Dataset')
2179 search.addOrderByAsc("name")
2180 if created:
2181 search.onlyCreatedBetween(created[0], created[1]);
2182 if text:
2183 search.setAllowLeadingWildcard(True)
2184 search.byFullText(str(text))
2185
2186 if search.hasNext():
2187 for e in search.results():
2188 yield DatasetWrapper(self, e)
2189
2190
2192 search = self.createSearchService()
2193 search.onlyType('Project')
2194 search.addOrderByAsc("name")
2195 if created:
2196 search.onlyCreatedBetween(created[0], created[1]);
2197 if text:
2198 search.setAllowLeadingWildcard(True)
2199 search.byFullText(str(text))
2200 if search.hasNext():
2201 for e in search.results():
2202 yield ProjectWrapper(self, e)
2203
2205 search = self.createSearchService()
2206 search.onlyType('Screen')
2207 search.addOrderByAsc("name")
2208 if created:
2209 search.onlyCreatedBetween(created[0], created[1]);
2210 if text:
2211 search.setAllowLeadingWildcard(True)
2212 search.byFullText(str(text))
2213 if search.hasNext():
2214 for e in search.results():
2215 yield ScreenWrapper(self, e)
2216
2218 search = self.createSearchService()
2219 search.onlyType('Plate')
2220 search.addOrderByAsc("name")
2221 if created:
2222 search.onlyCreatedBetween(created[0], created[1]);
2223 if text:
2224 search.setAllowLeadingWildcard(True)
2225 search.byFullText(str(text))
2226 if search.hasNext():
2227 for e in search.results():
2228 yield PlateWrapper(self, e)
2229
2231 """
2232 Fulltext search on Projects, Datasets and Images.
2233 TODO: search other object types?
2234 TODO: batch support.
2235 """
2236 if not text:
2237 return []
2238 if isinstance(text, UnicodeType):
2239 text = text.encode('utf8')
2240 if types is None:
2241 types = (ProjectWrapper, DatasetWrapper, ImageWrapper)
2242 search = self.createSearchService()
2243 if text[0] in ('?','*'):
2244 search.setAllowLeadingWildcard(True)
2245 rv = []
2246 for t in types:
2247 def actualSearch ():
2248 search.onlyType(t().OMERO_CLASS)
2249 search.byFullText(text)
2250 timeit(actualSearch)()
2251 if search.hasNext():
2252 def searchProcessing ():
2253 rv.extend(map(lambda x: t(self, x), search.results()))
2254 timeit(searchProcessing)()
2255 search.close()
2256 return rv
2257
2259 """
2260 Captures called function. Throws an exception.
2261
2262 @return:
2263 """
2264
2265 def inner (*args, **kwargs):
2266 try:
2267 return f(*args, **kwargs)
2268 except omero.ResourceError:
2269 logger.debug('captured resource error')
2270 raise
2271 except omero.SecurityViolation:
2272 raise
2273 except omero.ApiUsageException:
2274 raise
2275 except Ice.MemoryLimitException:
2276 raise
2277 except omero.InternalException:
2278 raise
2279 except Ice.Exception, x:
2280
2281 logger.debug( "Ice.Exception (1) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs)))
2282 logger.debug(traceback.format_exc())
2283
2284 try:
2285 self._obj = self._create_func()
2286 func = getattr(self._obj, attr)
2287 return func(*args, **kwargs)
2288 except Ice.MemoryLimitException:
2289 raise
2290 except Ice.Exception, x:
2291
2292 logger.debug("Ice.Exception (2) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs)))
2293 logger.debug(traceback.format_exc())
2294 try:
2295
2296 self._connect()
2297 logger.debug('last try for %s' % attr)
2298
2299 func = getattr(self._obj, attr)
2300 return func(*args, **kwargs)
2301 except:
2302 raise
2303
2304 def wrapped (*args, **kwargs):
2305 try:
2306 return inner(*args, **kwargs)
2307 except Ice.MemoryLimitException:
2308 logger.debug("MemoryLimitException! abort, abort...")
2309 raise
2310 except omero.SecurityViolation:
2311 logger.debug("SecurityViolation, bailing out")
2312 raise
2313 except omero.ApiUsageException:
2314 logger.debug("ApiUsageException, bailing out")
2315 raise
2316 except Ice.UnknownException:
2317 logger.debug("UnknownException, bailing out")
2318 raise
2319 except Ice.Exception, x:
2320 logger.debug('wrapped ' + f.func_name)
2321 logger.debug(x.__dict__)
2322 if x.serverExceptionClass == 'ome.conditions.InternalException':
2323 if x.message.find('java.lang.NullPointerException') > 0:
2324 logger.debug("NullPointerException, bailing out")
2325 raise
2326 elif x.message.find('Session is dirty') >= 0:
2327 logger.debug("Session is dirty, bailing out")
2328 raise
2329 else:
2330 logger.debug(x.message)
2331 logger.debug("exception caught, first time we back off for 10 secs")
2332 logger.debug(traceback.format_exc())
2333
2334 return inner(*args, **kwargs)
2335 return wrapped
2336
2337
2338 BlitzGateway = _BlitzGateway
2342 """ splits an hex stream of characters into an array of bytes in format (R,G,B,A).
2343 - abc -> (0xAA, 0xBB, 0xCC, 0xFF)
2344 - abcd -> (0xAA, 0xBB, 0xCC, 0xDD)
2345 - abbccd -> (0xAB, 0xBC, 0xCD, 0xFF)
2346 - abbccdde -> (0xAB, 0xBC, 0xCD, 0xDE)
2347 """
2348 try:
2349 out = []
2350 if len(color) in (3,4):
2351 c = color
2352 color = ''
2353 for e in c:
2354 color += e + e
2355 if len(color) == 6:
2356 color += 'FF'
2357 if len(color) == 8:
2358 for i in range(0, 8, 2):
2359 out.append(int(color[i:i+2], 16))
2360 return out
2361 except:
2362 pass
2363 return None
2364
2368 self._obj = None
2369 self._func_str = func_str
2370 self._resyncConn(conn)
2371 self._tainted = False
2372
2375
2377 """
2378 Returns True if connected.
2379
2380 @return: Boolean
2381 """
2382
2383 logger.debug("proxy_connect: a");
2384 if not self._conn.connect():
2385 logger.debug('connect failed')
2386 logger.debug('/n'.join(traceback.format_stack()))
2387 return False
2388 logger.debug("proxy_connect: b");
2389 self._resyncConn(self._conn)
2390 logger.debug("proxy_connect: c");
2391 self._obj = self._create_func()
2392 logger.debug("proxy_connect: d");
2393 return True
2394
2396 self._tainted = True
2397
2399 self._tainted = False
2400
2402 """
2403 Closes the underlaying service, so next call to the proxy will create a new
2404 instance of it.
2405 """
2406 if self._obj and isinstance(self._obj, omero.api.StatefulServiceInterfacePrx):
2407 self._obj.close()
2408 self._obj = None
2409
2411 """
2412
2413 @param conn: Connection
2414 """
2415
2416 self._conn = conn
2417 self._sf = conn.c.sf
2418 self._create_func = getattr(self._sf, self._func_str)
2419 if self._obj is not None:
2420 try:
2421 logger.debug("## - refreshing %s" % (self._func_str))
2422 obj = conn.c.ic.stringToProxy(str(self._obj))
2423 self._obj = self._obj.checkedCast(obj)
2424 except Ice.ObjectNotExistException:
2425 self._obj = None
2426
2428 """
2429
2430 @return: obj
2431 """
2432 if not self._obj:
2433 self._obj = self._create_func()
2434 else:
2435 self._ping()
2436 return self._obj
2437
2439 """
2440 For some reason, it seems that keepAlive doesn't, so every so often I need to recreate the objects.
2441
2442 @return: Boolean
2443 """
2444
2445 try:
2446 if not self._sf.keepAlive(self._obj):
2447 logger.debug("... died, recreating ...")
2448 self._obj = self._create_func()
2449 except Ice.ObjectNotExistException:
2450
2451 logger.debug("... reset, reconnecting")
2452 self._connect()
2453 return False
2454 except Ice.ConnectionLostException:
2455
2456 logger.debug(traceback.format_stack())
2457 logger.debug("... lost, reconnecting")
2458 self._conn._connected = False
2459 self._connect()
2460 return False
2461 except Ice.ConnectionRefusedException:
2462
2463 logger.debug(traceback.format_stack())
2464 logger.debug("... refused, reconnecting")
2465 self._connect()
2466 return False
2467 except omero.RemovedSessionException:
2468
2469 logger.debug(traceback.format_stack())
2470 logger.debug("... session has left the building, reconnecting")
2471 self._connect()
2472 return False
2473 except Ice.UnknownException:
2474
2475 logger.debug(traceback.format_stack())
2476 logger.debug("... ice says something bad happened, reconnecting")
2477 self._connect()
2478 return False
2479 return True
2480
2482 """
2483
2484 @param attr: Connection
2485 @return: rv
2486 """
2487
2488 obj = self._obj or self._getObj()
2489 rv = getattr(obj, attr)
2490 if callable(rv):
2491 rv = safeCallWrap(self, attr, rv)
2492
2493 return rv
2494
2497 """
2498 omero_model_AnnotationI class wrapper extends BlitzObjectWrapper.
2499 """
2500 registry = {}
2501 OMERO_TYPE = None
2502
2508
2511
2512 @classmethod
2515
2516 @classmethod
2517 - def _wrap (klass, conn, obj, link=None):
2518 if obj.__class__ in klass.registry:
2519 kwargs = dict()
2520 if link is not None:
2521 kwargs['link'] = BlitzObjectWrapper(conn, link)
2522 return klass.registry[obj.__class__](conn, obj, **kwargs)
2523 else:
2524 return None
2525
2526 @classmethod
2533
2535 return self._obj.ns is not None and self._obj.ns.val or None
2536
2539
2541 raise NotImplementedError
2542
2544 raise NotImplementedError
2545
2546 from omero_model_FileAnnotationI import FileAnnotationI
2549 """
2550 omero_model_FileAnnotatio class wrapper extends AnnotationWrapper.
2551 """
2552
2553 OMERO_TYPE = FileAnnotationI
2554
2558
2561
2564
2573
2576
2580
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611 AnnotationWrapper._register(FileAnnotationWrapper)
2612
2613 from omero_model_TimestampAnnotationI import TimestampAnnotationI
2616 """
2617 omero_model_TimestampAnnotatio class wrapper extends AnnotationWrapper.
2618 """
2619
2620 OMERO_TYPE = TimestampAnnotationI
2621
2623 return datetime.fromtimestamp(self._obj.timeValue.val / 1000.0)
2624
2626 if isinstance(val, datetime):
2627 self._obj.timeValue = rtime(long(time.mktime(val.timetuple())*1000))
2628 elif isinstance(val, omero.RTime):
2629 self._obj.timeValue = val
2630 else:
2631 self._obj.timeValue = rtime(long(val * 1000))
2632
2633 AnnotationWrapper._register(TimestampAnnotationWrapper)
2634
2635 from omero_model_BooleanAnnotationI import BooleanAnnotationI
2638 """
2639 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper.
2640 """
2641
2642 OMERO_TYPE = BooleanAnnotationI
2643
2645 return self._obj.boolValue.val
2646
2648 self._obj.boolValue = rbool(not not val)
2649
2650 AnnotationWrapper._register(BooleanAnnotationWrapper)
2651
2652 from omero_model_TagAnnotationI import TagAnnotationI
2655 """
2656 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper.
2657 """
2658
2659 OMERO_TYPE = TagAnnotationI
2660
2662 return self._obj.textValue.val
2663
2665 self._obj.textValue = rbool(not not val)
2666
2667 AnnotationWrapper._register(TagAnnotationWrapper)
2668
2669 from omero_model_CommentAnnotationI import CommentAnnotationI
2683
2684 AnnotationWrapper._register(CommentAnnotationWrapper)
2685
2686 from omero_model_LongAnnotationI import LongAnnotationI
2689 """
2690 omero_model_LongAnnotationI class wrapper extends AnnotationWrapper.
2691 """
2692 OMERO_TYPE = LongAnnotationI
2693
2695 return self._obj.longValue.val
2696
2698 self._obj.longValue = rlong(val)
2699
2700 AnnotationWrapper._register(LongAnnotationWrapper)
2701
2702 from omero_model_DoubleAnnotationI import DoubleAnnotationI
2705 """
2706 omero_model_DoubleAnnotationI class wrapper extends AnnotationWrapper.
2707 """
2708 OMERO_TYPE = DoubleAnnotationI
2709
2711 return self._obj.doubleValue.val
2712
2714 self._obj.doubleValue = rdouble(val)
2715
2716 AnnotationWrapper._register(DoubleAnnotationWrapper)
2717
2718 from omero_model_TermAnnotationI import TermAnnotationI
2721 """
2722 omero_model_TermAnnotationI class wrapper extends AnnotationWrapper.
2723 """
2724 OMERO_TYPE = TermAnnotationI
2725
2727 return self._obj.termValue.val
2728
2730 self._obj.termValue = rstring(val)
2731
2732 AnnotationWrapper._register(TermAnnotationWrapper)
2733
2734 from omero_model_XmlAnnotationI import XmlAnnotationI
2737 """
2738 omero_model_XmlAnnotationI class wrapper extends CommentAnnotationWrapper.
2739 """
2740 OMERO_TYPE = XmlAnnotationI
2741
2742 AnnotationWrapper._register(XmlAnnotationWrapper)
2745
2747 return self._obj.__class__
2748
2749 EnumerationWrapper = _EnumerationWrapper
2752 """
2753 omero_model_ExperimenterI class wrapper extends BlitzObjectWrapper.
2754 """
2755
2761
2763 rv = super(_ExperimenterWrapper, self).simpleMarshal(xtra=xtra, parents=parents)
2764 rv.update({'firstName': self.firstName,
2765 'middleName': self.middleName,
2766 'lastName': self.lastName,
2767 'email': self.email,
2768 'isAdmin': len(filter(lambda x: x.name.val == 'system', self._conn.getAdminService().containedGroups(self.getId()))) == 1,
2769 })
2770 return rv
2771
2773 """ Returns the experiments preferences annotation contents, as a ConfigParser instance """
2774 self._obj.unloadAnnotationLinks()
2775 cp = ConfigParser.SafeConfigParser()
2776 prefs = self.getAnnotation('TODO.changeme.preferences')
2777 if prefs is not None:
2778 prefs = prefs.getValue()
2779 if prefs is not None:
2780 cp.readfp(StringIO(prefs))
2781 return cp
2782
2784 """ Sets the experiments preferences annotation contents, passed in as a ConfigParser instance """
2785 ann = self.getAnnotation('TODO.changeme.preferences')
2786 t = StringIO()
2787 prefs.write(t)
2788 if ann is None:
2789 ann = CommentAnnotationWrapper()
2790 ann.setNs('TODO.changeme.preferences')
2791 ann.setValue(t.getvalue())
2792 self.linkAnnotation(ann)
2793 else:
2794 ann.setValue(t.getvalue())
2795 ann.save()
2796 self._obj.unloadAnnotationLinks()
2797
2799 if section is None:
2800 section = 'DEFAULT'
2801 try:
2802 return self.getRawPreferences().get(section, key)
2803 except ConfigParser.Error:
2804 return default
2805 return default
2806
2808 if section is None:
2809 section = 'DEFAULT'
2810 prefs = self.getRawPreferences()
2811 if prefs.has_section(section) or section == 'DEFAULT':
2812 return dict(prefs.items(section))
2813 return {}
2814
2823
2825 if not self._obj.details.owner:
2826 details = omero.model.DetailsI()
2827 details.owner = self._obj
2828 self._obj._details = details
2829 return DetailsWrapper(self._conn, self._obj.details)
2830
2833
2836
2838 """
2839 Gets full name of this experimenter.
2840
2841 @return: String or None
2842 """
2843
2844 try:
2845 if self.middleName is not None and self.middleName != '':
2846 name = "%s %s. %s" % (self.firstName, self.middleName[:1].upper(), self.lastName)
2847 else:
2848 name = "%s %s" % (self.firstName, self.lastName)
2849 except:
2850 logger.error(traceback.format_exc())
2851 name = self.omeName
2852 return name
2853
2855 try:
2856 if self.firstName is not None and self.lastName is not None:
2857 name = "%s. %s" % (self.firstName[:1], self.lastName)
2858 else:
2859 name = self.omeName
2860 except:
2861 logger.error(traceback.format_exc())
2862 name = self.omeName
2863 return name
2864
2866 for ob in self._obj.copyGroupExperimenterMap():
2867 if ob.parent.name.val == "system":
2868 return True
2869 return False
2870
2872 for ob in self._obj.copyGroupExperimenterMap():
2873 if ob.parent.name.val == "user":
2874 return True
2875 return False
2876
2878 for ob in self._obj.copyGroupExperimenterMap():
2879 if ob.parent.name.val == "guest":
2880 return True
2881 return False
2882
2883 ExperimenterWrapper = _ExperimenterWrapper
2886 """
2887 omero_model_ExperimenterGroupI class wrapper extends BlitzObjectWrapper.
2888 """
2889
2895
2900
2901 ExperimenterGroupWrapper = _ExperimenterGroupWrapper
2904 """
2905 omero_model_DetailsI class wrapper extends BlitzObjectWrapper.
2906 """
2907
2914
2917
2920
2922 """
2923 omero_model_DatasetI class wrapper extends BlitzObjectWrapper.
2924 """
2925
2931
2933 super(_DatasetWrapper, self).__loadedHotSwap__()
2934 if not self._obj.isImageLinksLoaded():
2935 links = self._conn.getQueryService().findAllByQuery("select l from DatasetImageLink as l join fetch l.child as a where l.parent.id=%i" % (self._oid), None)
2936 self._obj._imageLinksLoaded = True
2937 self._obj._imageLinksSeq = links
2938
2939 DatasetWrapper = _DatasetWrapper
2942 """
2943 omero_model_ProjectI class wrapper extends BlitzObjectWrapper.
2944 """
2945
2951
2952 ProjectWrapper = _ProjectWrapper
2963
2964 ScreenWrapper = _ScreenWrapper
2975
2976 PlateWrapper = _PlateWrapper
2979
2985
2987 try:
2988 self.index = int(kwargs['index'])
2989 except:
2990 self.index = 0
2991
2993 """ return boolean if object exist """
2994 if getattr(self, 'isWellSamplesLoaded')():
2995 childnodes = getattr(self, 'copyWellSamples')()
2996 logger.debug('listChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
2997 if len(childnodes) > 0:
2998 return True
2999 return False
3000
3002 """ return boolean if object exist """
3003 if getattr(self, 'isWellSamplesLoaded')():
3004 childnodes = getattr(self, 'copyWellSamples')()
3005 logger.debug('countChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3006 size = len(childnodes)
3007 if size > 0:
3008 return size
3009 return 0
3010
3012 """ return a wrapped child object """
3013 if getattr(self, 'isWellSamplesLoaded')():
3014 childnodes = getattr(self, 'copyWellSamples')()
3015 logger.debug('listSelectedChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3016 if len(childnodes) > 0:
3017 return WellSampleWrapper(self._conn, childnodes[self.index])
3018 return None
3019
3021 """ return a generator yielding child objects """
3022 if getattr(self, 'isWellSamplesLoaded')():
3023 childnodes = getattr(self, 'copyWellSamples')()
3024 logger.debug('listChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3025 for ch in childnodes:
3026 yield WellSampleWrapper(self._conn, ch)
3027
3029 return PlateWrapper(self._conn, self._obj.plate)
3030
3031 WellWrapper = _WellWrapper
3034
3039
3041 return ImageWrapper(self._conn, self._obj.image)
3042
3043 WellSampleWrapper = _WellSampleWrapper
3046
3048 return datetime.fromtimestamp(self.getStarted().val/1000)
3049
3051 try:
3052 return datetime.fromtimestamp((self.getStarted().val+self.getTimeToLive().val)/1000)
3053 except ValueError:
3054 pass
3055 return None
3056
3058 try:
3059 if (self.getStarted().val+self.getTimeToLive().val)/1000 <= time.time():
3060 return True
3061 else:
3062 return False
3063 except:
3064 return True
3065
3067 try:
3068 if self.owner.id.val == self._conn.getEventContext().userId:
3069 return True
3070 except:
3071 logger.error(traceback.format_exc())
3072 return False
3073
3075 return omero.gateway.ExperimenterWrapper(self, self.owner)
3076
3077 ShareWrapper = _ShareWrapper
3078
3079 -class ShareContentWrapper (BlitzObjectWrapper):
3081
3084
3088 """
3089 Stores color internally as (R,G,B,A) and allows setting and getting in multiple formats
3090 """
3091
3092 _color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255}
3093
3095 self._color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255}
3096 if colorname and colorname.lower() in self._color.keys():
3097 self._color[colorname.lower()] = 255
3098
3099 @classmethod
3107
3109 return self._color['red']
3110
3112 """
3113 Set red, as int 0..255
3114
3115 @param val: value of Red.
3116 """
3117
3118 self._color['red'] = max(min(255, int(val)), 0)
3119
3121 return self._color['green']
3122
3124 """
3125 Set green, as int 0..255
3126
3127 @param val: value of Green.
3128 """
3129
3130 self._color['green'] = max(min(255, int(val)), 0)
3131
3133 return self._color['blue']
3134
3136 """
3137 Set Blue, as int 0..255
3138
3139 @param val: value of Blue.
3140 """
3141
3142 self._color['blue'] = max(min(255, int(val)), 0)
3143
3145 return self._color['alpha']
3146
3148 """
3149 Set alpha, as int 0..255.
3150 @param val: value of alpha.
3151 """
3152
3153 self._color['alpha'] = max(min(255, int(val)), 0)
3154
3156 """
3157 @return: String. The html usable color. Dumps the alpha information.
3158 """
3159
3160 return "%(red)0.2X%(green)0.2X%(blue)0.2X" % (self._color)
3161
3163 """
3164 @return: String. rgba(r,g,b,a) for this color.
3165 """
3166
3167 c = self._color.copy()
3168 c['alpha'] /= 255.0
3169 return "rgba(%(red)i,%(green)i,%(blue)i,%(alpha)0.3f)" % (c)
3170
3172 """
3173 @return: list. A list of (r,g,b) values
3174 """
3175
3176 return (self._color['red'], self._color['green'], self._color['blue'])
3177
3179 """
3180 omero_model_LogicalChannelI class wrapper extends BlitzObjectWrapper.
3181 """
3182 _attrs = ('name',
3183 'pinHoleSize',
3184 '#illumination',
3185 'contrastMethod',
3186 'excitationWave',
3187 'emissionWave',
3188 'fluor',
3189 'ndFilter',
3190 'otf',
3191 'detectorSettings|DetectorSettingsWrapper',
3192 'lightSourceSettings|LightSettingsWrapper',
3193 'filterSet|FilterSetWrapper',
3194 'lightPath|LightPathWrapper',
3195 'samplesPerPixel',
3196 '#photometricInterpretation',
3197 'mode',
3198 'pockelCellSetting',
3199 'shapes',
3200 'version')
3201
3202 LogicalChannelWrapper = _LogicalChannelWrapper
3205 """
3206 base Light Source class wrapper, extends BlitzObjectWrapper.
3207 """
3208 _attrs = ('dichroic|DichroicWrapper')
3209
3210
3211
3214
3217
3220
3221 LightPathWrapper = _LightPathWrapper
3224 """
3225 omero_model_ChannelI class wrapper extends BlitzObjectWrapper.
3226 """
3227
3228 BLUE_MIN = 400
3229 BLUE_MAX = 500
3230 GREEN_MIN = 501
3231 GREEN_MAX = 600
3232 RED_MIN = 601
3233 RED_MAX = 700
3234 COLOR_MAP = ((BLUE_MIN, BLUE_MAX, ColorHolder('Blue')),
3235 (GREEN_MIN, GREEN_MAX, ColorHolder('Green')),
3236 (RED_MIN, RED_MAX, ColorHolder('Red')),
3237 )
3238
3241
3243 self._re = re
3244 self._idx = idx
3245 self._img = img
3246
3250
3253
3255 if self._obj.logicalChannel is not None:
3256 return LogicalChannelWrapper(self._conn, self._obj.logicalChannel)
3257
3259 lc = self.getLogicalChannel()
3260 rv = lc.name
3261 if rv is None:
3262 rv = lc.emissionWave
3263 if rv is None:
3264 rv = self._idx
3265 return rv
3266
3269
3271 return int(self._re.getChannelWindowStart(self._idx))
3272
3275
3277 return int(self._re.getChannelWindowEnd(self._idx))
3278
3281
3283 self._re.setChannelWindow(self._idx, float(minval), float(maxval))
3284
3286 return self._obj.getStatsInfo().getGlobalMin().val
3287
3289 return self._obj.getStatsInfo().getGlobalMax().val
3290
3291 ChannelWrapper = _ChannelWrapper
3294 def wrapped (self, *args, **kwargs):
3295 if not self._prepareRenderingEngine():
3296 return None
3297 return func(self, *args, **kwargs)
3298 return wrapped
3299
3301 def wrapped (self, *args, **kwargs):
3302 if not self._loadPixels():
3303 return None
3304 return func(self, *args, **kwargs)
3305 return wrapped
3306
3309 """
3310 omero_model_ImageI class wrapper extends BlitzObjectWrapper.
3311 """
3312
3313 _re = None
3314 _pd = None
3315 _rm = {}
3316 _pixels = None
3317
3318 _pr = None
3319
3320 PROJECTIONS = {
3321 'normal': -1,
3322 'intmax': omero.constants.projection.ProjectionType.MAXIMUMINTENSITY,
3323 'intmean': omero.constants.projection.ProjectionType.MEANINTENSITY,
3324 'intsum': omero.constants.projection.ProjectionType.SUMINTENSITY,
3325 }
3326
3327 PLANEDEF = omero.romio.XY
3328
3329 @classmethod
3336
3342
3345
3348
3350 i = self._obj.instrument
3351 if i is None:
3352 return None
3353 if not i.loaded:
3354 self._obj.instrument = self._conn.getQueryService().find('Instrument', i.id.val)
3355 i = self._obj.instrument
3356 meta_serv = self._conn.getMetadataService()
3357 instruments = meta_serv.loadInstrument(i.id.val)
3358
3359 if instruments._detectorLoaded:
3360 i._detectorSeq.extend(instruments._detectorSeq)
3361 if instruments._objectiveLoaded:
3362 i._objectiveSeq.extend(instruments._objectiveSeq)
3363 if instruments._lightSourceLoaded:
3364 i._lightSourceSeq.extend(instruments._lightSourceSeq)
3365 if instruments._filterLoaded:
3366 i._filterSeq.extend(instruments._filterSeq)
3367 if instruments._dichroicLoaded:
3368 i._dichroicSeq.extend(instruments._dichroicSeq)
3369 if instruments._filterSetLoaded:
3370 i._filterSetSeq.extend(instruments._filterSetSeq)
3371 if instruments._otfLoaded:
3372 i._otfSeq.extend(instruments._otfSeq)
3373
3374 return InstrumentWrapper(self._conn, i)
3375
3377 if not self._obj.pixelsLoaded:
3378 self.__loadedHotSwap__()
3379 return self._obj.sizeOfPixels() > 0
3380
3382 re = self._conn.createRenderingEngine()
3383 pixels_id = self._obj.getPrimaryPixels().id.val
3384 re.lookupPixels(pixels_id)
3385 if re.lookupRenderingDef(pixels_id) == False:
3386 try:
3387 re.resetDefaults()
3388 except omero.ResourceError:
3389
3390 return False
3391 re.lookupRenderingDef(pixels_id)
3392 re.load()
3393 return re
3394
3404
3411
3413 rv = super(_ImageWrapper, self).simpleMarshal(xtra=xtra, parents=parents)
3414 rv.update({'author': self.getAuthor(),
3415 'date': time.mktime(self.getDate().timetuple()),})
3416 if xtra:
3417 if xtra.has_key('thumbUrlPrefix'):
3418 if callable(xtra['thumbUrlPrefix']):
3419 rv['thumb_url'] = xtra['thumbUrlPrefix'](str(self.id))
3420 else:
3421 rv['thumb_url'] = xtra['thumbUrlPrefix'] + str(self.id) + '/'
3422 return rv
3423
3425 if self._obj.stageLabel is None:
3426 return None
3427 else:
3428 return ImageStageLabelWrapper(self._conn, self._obj.stageLabel)
3429
3431 name = self.name
3432 if not name:
3433 return ""
3434 l = len(name)
3435 if l < length+hist:
3436 return name
3437 return "..." + name[l - length:]
3438
3440 q = self._conn.getQueryService()
3441 e = q.findByQuery("select e from Experimenter e where e.id = %i" % self._obj.details.owner.id.val,None)
3442 self._author = e.firstName.val + " " + e.lastName.val
3443 return self._author
3444
3446 try:
3447 q = """
3448 select ds from Image i join i.datasetLinks dl join dl.parent ds
3449 where i.id = %i
3450 """ % self._obj.id.val
3451 query = self._conn.getQueryService()
3452 ds = query.findByQuery(q,None)
3453 return ds and DatasetWrapper(self._conn, ds) or None
3454 except:
3455 logger.debug('on getDataset')
3456 logger.debug(traceback.format_exc())
3457 return None
3458
3460 try:
3461 q = """
3462 select p from Image i join i.datasetLinks dl join dl.parent ds join ds.projectLinks pl join pl.parent p
3463 where i.id = %i
3464 """ % self._obj.id.val
3465 query = self._conn.getQueryService()
3466 prj = query.findByQuery(q,None)
3467 return prj and ProjectWrapper(self._conn, prj) or None
3468 except:
3469 logger.debug('on getProject')
3470 logger.debug(traceback.format_exc())
3471 return None
3472
3474 try:
3475 query = self._conn.getQueryService()
3476 event = query.findByQuery("select e from Event e where id = %i" % self._obj.details.creationEvent.id.val, None)
3477 return datetime.fromtimestamp(event.time.val / 1000)
3478 except:
3479 logger.debug('on getDate')
3480 logger.debug(traceback.format_exc())
3481
3482 return datetime.fromtimestamp(event.time.val / 1000)
3483
3485 rv = self.objectiveSettings
3486 if self.objectiveSettings is not None:
3487 rv = ObjectiveSettingsWrapper(self._conn, self.objectiveSettings)
3488 if not self.objectiveSettings.loaded:
3489 self.objectiveSettings = rv._obj
3490 return rv
3491
3493 rv = self.imagingEnvironment
3494 if self.imagingEnvironment is not None:
3495 rv = ImagingEnvironmentWrapper(self._conn, self.imagingEnvironment)
3496 if not self.imagingEnvironment.loaded:
3497 self.imagingEnvironment = rv._obj
3498 return rv
3499
3500 @assert_pixels
3503
3504 @assert_pixels
3507
3509 pixels_id = self.getPixelsId()
3510 if pixels_id is None:
3511 return None
3512 tb = self._conn.createThumbnailStore()
3513 try:
3514 rv = tb.setPixelsId(pixels_id)
3515 except omero.InternalException:
3516 logger.error(traceback.print_exc())
3517 rv = False
3518 if not rv:
3519 tb.resetDefaults()
3520 tb.close()
3521 tb.setPixelsId(pixels_id)
3522 return tb
3523
3552
3554 try:
3555 tb = self._prepareTB()
3556 if tb is None:
3557 return None
3558 if isinstance(size, IntType):
3559 size = (size,)
3560 if z is not None and t is not None:
3561 pos = z,t
3562 else:
3563 pos = None
3564 if len(size) == 1:
3565 if pos is None:
3566 thumb = tb.getThumbnailByLongestSideDirect
3567 else:
3568 thumb = tb.getThumbnailForSectionByLongestSideDirect
3569 else:
3570 if pos is None:
3571 thumb = tb.getThumbnailDirect
3572 else:
3573 thumb = tb.getThumbnailForSectionDirect
3574 args = map(lambda x: rint(x), size)
3575 if pos is not None:
3576 args = list(pos) + args
3577 rv = thumb(*args)
3578 return rv
3579 except Exception:
3580 logger.error(traceback.print_exc())
3581 return None
3582
3583 @assert_pixels
3585 """ Returns (min, max) values for the pixels type of this image.
3586 TODO: Does not handle floats correctly, though."""
3587 pixels_id = self._obj.getPrimaryPixels().getId().val
3588 rp = self._conn.createRawPixelsStore()
3589 rp.setPixelsId(pixels_id, True)
3590 pmax = 2 ** (8 * rp.getByteWidth())
3591 if rp.isSigned():
3592 return (-(pmax / 2), pmax / 2 - 1)
3593 else:
3594 return (0, pmax-1)
3595
3596 @assert_re
3598 return [ChannelWrapper(self._conn, c, idx=n, re=self._re, img=self) for n,c in enumerate(self._re.getPixels().iterateChannels())]
3599
3601 for c in range(len(self.getChannels())):
3602 self._re.setActive(c, (c+1) in channels)
3603 if (c+1) in channels:
3604 if windows is not None and windows[c][0] is not None and windows[c][1] is not None:
3605 self._re.setChannelWindow(c, *windows[c])
3606 if colors is not None and colors[c]:
3607 rgba = splitHTMLColor(colors[c])
3608 if rgba:
3609 self._re.setRGBA(c, *rgba)
3610 return True
3611
3614
3617
3618 LINE_PLOT_DTYPES = {
3619 (4, True, True): 'f',
3620 (2, False, False): 'H',
3621 (2, False, True): 'h',
3622 (1, False, False): 'B',
3623 (1, False, True): 'b',
3624 }
3625
3626 - def getPixelLine (self, z, t, pos, axis, channels=None, range=None):
3627 """
3628 Grab a horizontal or vertical line from the image pixel data, for the specified channels
3629 (or all if not specified) and using the specified range (or 1:1 relative to the image size).
3630 Axis may be 'h' or 'v', for horizontal or vertical respectively.
3631
3632 @param z:
3633 @param t:
3634 @param pos:
3635 @param axis:
3636 @param channels:
3637 @param range:
3638 @return: rv
3639 """
3640
3641 if not self._loadPixels():
3642 logger.debug( "No pixels!")
3643 return None
3644 axis = axis.lower()[:1]
3645 if channels is None:
3646 channels = map(lambda x: x._idx, filter(lambda x: x.isActive(), self.getChannels()))
3647 if range is None:
3648 range = axis == 'h' and self.getHeight() or self.getWidth()
3649 if not isinstance(channels, (TupleType, ListType)):
3650 channels = (channels,)
3651 chw = map(lambda x: (x.getWindowMin(), x.getWindowMax()), self.getChannels())
3652 rv = []
3653 pixels_id = self._obj.getPrimaryPixels().getId().val
3654 rp = self._conn.createRawPixelsStore()
3655 rp.setPixelsId(pixels_id, True)
3656 for c in channels:
3657 bw = rp.getByteWidth()
3658 key = self.LINE_PLOT_DTYPES.get((bw, rp.isFloat(), rp.isSigned()), None)
3659 if key is None:
3660 logger.error("Unknown data type: " + str((bw, rp.isFloat(), rp.isSigned())))
3661 plot = array.array(key, axis == 'h' and rp.getRow(pos, z, c, t) or rp.getCol(pos, z, c, t))
3662 plot.byteswap()
3663
3664 offset = -chw[c][0]
3665 if offset != 0:
3666 plot = map(lambda x: x+offset, plot)
3667 normalize = 1.0/chw[c][1]*(range-1)
3668 if normalize != 1.0:
3669 plot = map(lambda x: x*normalize, plot)
3670 if isinstance(plot, array.array):
3671 plot = plot.tolist()
3672 rv.append(plot)
3673 return rv
3674
3675
3676 - def getRow (self, z, t, y, channels=None, range=None):
3678
3679 - def getCol (self, z, t, x, channels=None, range=None):
3681
3682 @assert_re
3684 if not len(self._rm):
3685 for m in [BlitzObjectWrapper(self._conn, m) for m in self._re.getAvailableModels()]:
3686 self._rm[m.value.lower()] = m
3687 return self._rm.values()
3688
3689 @assert_re
3692
3694 """
3695 Sets the Greyscale rendering model on this image's current renderer
3696 """
3697
3698 rm = self.getRenderingModels()
3699 self._re.setModel(self._rm.get('greyscale', rm[0])._obj)
3700
3702 """
3703 Sets the HSB rendering model on this image's current renderer
3704 """
3705
3706 rm = self.getRenderingModels()
3707 self._re.setModel(self._rm.get('rgb', rm[0])._obj)
3708
3711
3712 @assert_re
3714 self._pd.z = long(z)
3715 self._pd.t = long(t)
3716 try:
3717 if compression is not None:
3718 try:
3719 self._re.setCompressionLevel(float(compression))
3720 except omero.SecurityViolation:
3721 self._obj.clearPixels()
3722 self._obj.pixelsLoaded = False
3723 self._re = None
3724 return self.renderJpeg(z,t,None)
3725 projection = self.PROJECTIONS.get(self._pr, -1)
3726 if not isinstance(projection, omero.constants.projection.ProjectionType):
3727 rv = self._re.renderCompressed(self._pd)
3728 else:
3729 rv = self._re.renderProjectedCompressed(projection, self._pd.t, 1, 0, self.z_count()-1)
3730 return rv
3731 except omero.InternalException:
3732 logger.debug('On renderJpeg');
3733 logger.debug(traceback.format_exc())
3734 return None
3735 except Ice.MemoryLimitException:
3736
3737 self._obj.clearPixels()
3738 self._obj.pixelsLoaded = False
3739 self._re = None
3740 raise
3741
3743 e = self._conn.createExporter()
3744 e.addImage(self.getId())
3745 size = e.generateTiff()
3746 p = 0
3747 rv = ''
3748 while p < size:
3749 s = min(65536, size-p)
3750 rv += e.read(p,s)
3751 p += s
3752 e.close()
3753 return rv
3754
3756 rv = self.renderJpeg(z,t,compression)
3757 if rv is not None:
3758 i = StringIO(rv)
3759 rv = Image.open(i)
3760 return rv
3761
3763 """
3764 Prepares a jpeg representation of a 2d grid holding a render of each channel,
3765 along with one for all channels at the set Z and T points.
3766
3767 @param z:
3768 @param t:
3769 @param compression:
3770 @param border:
3771 @return: value
3772 """
3773
3774 img = self.renderSplitChannelImage(z,t,compression, border)
3775 rv = StringIO()
3776 img.save(rv, 'jpeg', quality=int(compression*100))
3777 return rv.getvalue()
3778
3780 c = self.c_count()
3781
3782 x = sqrt(c)
3783 y = int(round(x))
3784 if x > y:
3785 x = y+1
3786 else:
3787 x = y
3788 rv = {'g':{'width': self.getWidth()*x + border*(x+1),
3789 'height': self.getHeight()*y+border*(y+1),
3790 'border': border,
3791 'gridx': x,
3792 'gridy': y,}
3793 }
3794
3795 c += 1
3796 x = sqrt(c)
3797 y = int(round(x))
3798 if x > y:
3799 x = y+1
3800 else:
3801 x = y
3802 rv['c'] = {'width': self.getWidth()*x + border*(x+1),
3803 'height': self.getHeight()*y+border*(y+1),
3804 'border': border,
3805 'gridx': x,
3806 'gridy': y,}
3807 return rv
3808
3810 """
3811 Prepares a PIL Image with a 2d grid holding a render of each channel,
3812 along with one for all channels at the set Z and T points.
3813
3814 @param z:
3815 @param t:
3816 @param compression:
3817 @param border:
3818 @return: canvas
3819 """
3820
3821 dims = self.splitChannelDims(border=border)[self.isGreyscaleRenderingModel() and 'g' or 'c']
3822 canvas = Image.new('RGBA', (dims['width'], dims['height']), '#fff')
3823 cmap = [ch.isActive() and i+1 or 0 for i,ch in enumerate(self.getChannels())]
3824 c = self.c_count()
3825 pxc = 0
3826 px = dims['border']
3827 py = dims['border']
3828
3829
3830 w = self.getWidth()
3831 if w >= 640:
3832 fsize = (int((w-640)/128)*8) + 24
3833 if fsize > 64:
3834 fsize = 64
3835 elif w >= 512:
3836 fsize = 24
3837 elif w >= 384:
3838 fsize = 18
3839 elif w >= 298:
3840 fsize = 14
3841 elif w >= 256:
3842 fsize = 12
3843 elif w >= 213:
3844 fsize = 10
3845 elif w >= 96:
3846 fsize = 8
3847 else:
3848 fsize = 0
3849 if fsize > 0:
3850 font = ImageFont.load('%s/pilfonts/B%0.2d.pil' % (THISPATH, fsize) )
3851
3852
3853 for i in range(c):
3854 if cmap[i]:
3855 self.setActiveChannels((i+1,))
3856 img = self.renderImage(z,t, compression)
3857 if fsize > 0:
3858 draw = ImageDraw.ImageDraw(img)
3859 draw.text((2,2), "%s" % (str(self.getChannels()[i].getEmissionWave())), font=font, fill="#fff")
3860 canvas.paste(img, (px, py))
3861 pxc += 1
3862 if pxc < dims['gridx']:
3863 px += self.getWidth() + border
3864 else:
3865 pxc = 0
3866 px = border
3867 py += self.getHeight() + border
3868 if not self.isGreyscaleRenderingModel():
3869 self.setActiveChannels(cmap)
3870 img = self.renderImage(z,t, compression)
3871 if fsize > 0:
3872 draw = ImageDraw.ImageDraw(img)
3873 draw.text((2,2), "merged", font=font, fill="#fff")
3874 canvas.paste(img, (px, py))
3875 return canvas
3876
3877 LP_PALLETE = [0,0,0,0,0,0,255,255,255]
3878 LP_TRANSPARENT = 0
3879 LP_BGCOLOR = 1
3880 LP_FGCOLOR = 2
3882 """
3883 Common part of horizontal and vertical line plot rendering.
3884 @returns: (Image, width, height).
3885 """
3886 channels = filter(lambda x: x.isActive(), self.getChannels())
3887 width = self.getWidth()
3888 height = self.getHeight()
3889
3890 pal = list(self.LP_PALLETE)
3891
3892 for channel in channels:
3893 pal.extend(channel.getColor().getRGB())
3894
3895
3896 im = Image.new('P', (width, height))
3897 im.putpalette(pal)
3898 return im, width, height
3899
3900
3901 @assert_re
3903 self._pd.z = long(z)
3904 self._pd.t = long(t)
3905
3906 im, width, height = self.prepareLinePlotCanvas(z,t)
3907 base = height - 1
3908
3909 draw = ImageDraw.ImageDraw(im)
3910
3911 draw.rectangle([0, 0, width-1, base], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT)
3912 draw.line(((0,y),(width, y)), fill=self.LP_FGCOLOR, width=linewidth)
3913
3914
3915 rows = self.getRow(z,t,y)
3916
3917 for r in range(len(rows)):
3918 chrow = rows[r]
3919 color = r + self.LP_FGCOLOR + 1
3920 last_point = base-chrow[0]
3921 for i in range(len(chrow)):
3922 draw.line(((i, last_point), (i, base-chrow[i])), fill=color, width=linewidth)
3923 last_point = base-chrow[i]
3924 del draw
3925 out = StringIO()
3926 im.save(out, format="gif", transparency=0)
3927 return out.getvalue()
3928
3929 @assert_re
3931 self._pd.z = long(z)
3932 self._pd.t = long(t)
3933
3934 im, width, height = self.prepareLinePlotCanvas(z,t)
3935
3936 draw = ImageDraw.ImageDraw(im)
3937
3938 draw.rectangle([0, 0, width-1, height-1], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT)
3939 draw.line(((x,0),(x, height)), fill=self.LP_FGCOLOR, width=linewidth)
3940
3941
3942 cols = self.getCol(z,t,x)
3943
3944 for r in range(len(cols)):
3945 chcol = cols[r]
3946 color = r + self.LP_FGCOLOR + 1
3947 last_point = chcol[0]
3948 for i in range(len(chcol)):
3949 draw.line(((last_point, i), (chcol[i], i)), fill=color, width=linewidth)
3950 last_point = chcol[i]
3951 del draw
3952 out = StringIO()
3953 im.save(out, format="gif", transparency=0)
3954 return out.getvalue()
3955
3956 @assert_re
3959
3960 @assert_re
3963
3964 @assert_pixels
3966 rv = self._obj.getPrimaryPixels().getPhysicalSizeX()
3967 return rv is not None and rv.val or 0
3968
3969 @assert_pixels
3971 rv = self._obj.getPrimaryPixels().getPhysicalSizeY()
3972 return rv is not None and rv.val or 0
3973
3974 @assert_pixels
3976 rv = self._obj.getPrimaryPixels().getPhysicalSizeZ()
3977 return rv is not None and rv.val or 0
3978
3979 @assert_pixels
3982
3983 @assert_pixels
3986
3987 @assert_pixels
3990
3991 @assert_pixels
3994
3995 @assert_pixels
3998
4000 """
4001 Removes specific color settings from channels
4002
4003 @return: Boolean
4004 """
4005
4006 if not self.canWrite():
4007 return False
4008 for c in self.getChannels():
4009 c.unloadRed()
4010 c.unloadGreen()
4011 c.unloadBlue()
4012 c.unloadAlpha()
4013 c.save()
4014 self._conn.getDeleteService().deleteSettings(self.getId())
4015 return True
4016
4017 @assert_re
4019 """
4020 Limited support for saving the current prepared image rendering defs.
4021 Right now only channel colors are saved back.
4022
4023 @return: Boolean
4024 """
4025
4026 if not self.canWrite():
4027 return False
4028 self._re.saveCurrentSettings()
4029 return True
4030
4031 ImageWrapper = _ImageWrapper
4037
4038 ImageStageLabelWrapper = _ImageStageLabelWrapper
4042
4043 ImagingEnvironmentWrapper = _ImagingEnvironmentWrapper
4046 """
4047 omero_model_ImagingEnvironmentI class wrapper extends BlitzObjectWrapper.
4048 """
4049 _attrs = ('temperature',
4050 'airPressure',
4051 'humidity',
4052 'co2percent',
4053 'version')
4054
4057
4058 ImagingEnviromentWrapper = _ImagingEnviromentWrapper
4061 """
4062 omero_model_TransmittanceRangeI class wrapper extends BlitzObjectWrapper.
4063 """
4064 _attrs = ('cutIn',
4065 'cutOut',
4066 'cutInTolerance',
4067 'cutOutTolerance',
4068 'transmittance',
4069 'version')
4070
4073
4074 TransmittanceRangeWrapper = _TransmittanceRangeWrapper
4077 """
4078 omero_model_DetectorSettingsI class wrapper extends BlitzObjectWrapper.
4079 """
4080 _attrs = ('voltage',
4081 'gain',
4082 'offsetValue',
4083 'readOutRate',
4084 'binning',
4085 'detector|DetectorWrapper',
4086 'version')
4087
4090
4091 DetectorSettingsWrapper = _DetectorSettingsWrapper
4094 """
4095 omero_model_DetectorI class wrapper extends BlitzObjectWrapper.
4096 """
4097 _attrs = ('manufacturer',
4098 'model',
4099 'serialNumber',
4100 'voltage',
4101 'gain',
4102 'offsetValue',
4103 'zoom',
4104 'amplificationGain',
4105 '#type;detectorType',
4106 'version')
4107
4110
4112 rv = self.type
4113 if self.type is not None:
4114 rv = EnumerationWrapper(self._conn, self.type)
4115 if not self.type.loaded:
4116 self.type = rv._obj
4117 return rv
4118
4119 DetectorWrapper = _DetectorWrapper
4122 """
4123 omero_model_ObjectiveI class wrapper extends BlitzObjectWrapper.
4124 """
4125 _attrs = ('manufacturer',
4126 'model',
4127 'serialNumber',
4128 'nominalMagnification',
4129 'calibratedMagnification',
4130 'lensNA',
4131 '#immersion',
4132 '#correction',
4133 'workingDistance',
4134 '#iris',
4135 'version')
4136
4139
4141 rv = self.immersion
4142 if self.immersion is not None:
4143 rv = EnumerationWrapper(self._conn, self.immersion)
4144 if not self.immersion.loaded:
4145 self.immersion = rv._obj
4146 return rv
4147
4149 rv = self.correction
4150 if self.correction is not None:
4151 rv = EnumerationWrapper(self._conn, self.correction)
4152 if not self.correction.loaded:
4153 self.correction = rv._obj
4154 return rv
4155
4157 rv = self.iris
4158 if self.iris is not None:
4159 rv = EnumerationWrapper(self._conn, self.iris)
4160 if not self.iris.loaded:
4161 self.iris = rv._obj
4162 return rv
4163
4164 ObjectiveWrapper = _ObjectiveWrapper
4167 """
4168 omero_model_ObjectiveSettingsI class wrapper extends BlitzObjectWrapper.
4169 """
4170 _attrs = ('correctionCollar',
4171 '#medium',
4172 'refractiveIndex',
4173 'objective|ObjectiveWrapper',
4174 'version')
4175
4178
4180 rv = self.objective
4181 if self.objective is not None:
4182 rv = ObjectiveWrapper(self._conn, self.objective)
4183 if not self.objective.loaded:
4184 self.objective = rv._obj
4185 return rv
4186
4188 rv = self.medium
4189 if self.medium is not None:
4190 rv = EnumerationWrapper(self._conn, self.medium)
4191 if not self.medium.loaded:
4192 self.medium = rv._obj
4193 return rv
4194
4195 ObjectiveSettingsWrapper = _ObjectiveSettingsWrapper
4199 """
4200 omero_model_FilterI class wrapper extends BlitzObjectWrapper.
4201 """
4202 _attrs = ('manufacturer',
4203 'model',
4204 'lotNumber',
4205 'filterWheel',
4206 '#type;filterType',
4207 'transmittanceRange|TransmittanceRangeWrapper',
4208 'version')
4209
4212
4214 rv = self.type
4215 if self.type is not None:
4216 rv = EnumerationWrapper(self._conn, self.type)
4217 if not self.type.loaded:
4218 self.type = rv._obj
4219 return rv
4220
4221 FilterWrapper = _FilterWrapper
4224 """
4225 omero_model_DichroicI class wrapper extends BlitzObjectWrapper.
4226 """
4227 _attrs = ('manufacturer',
4228 'model',
4229 'lotNumber',
4230 'version')
4231
4234
4235 DichroicWrapper = _DichroicWrapper
4238 """
4239 omero_model_FilterSetI class wrapper extends BlitzObjectWrapper.
4240 """
4241 _attrs = ('manufacturer',
4242 'model',
4243 'lotNumber',
4244
4245
4246 'dichroic|DichroicWrapper',
4247 'version')
4248
4251
4254
4257
4258 FilterSetWrapper = _FilterSetWrapper
4261 """
4262 omero_model_OTFI class wrapper extends BlitzObjectWrapper.
4263 """
4264 _attrs = ('sizeX',
4265 'sizeY',
4266 'opticalAxisAveraged'
4267 'pixelsType',
4268 'path',
4269 'filterSet|FilterSetWrapper',
4270 'objective|ObjectiveWrapper',
4271 'version')
4272
4275
4276 OTFWrapper = _OTFWrapper
4279 """
4280 base Light Source class wrapper, extends BlitzObjectWrapper.
4281 """
4282 _attrs = ('attenuation',
4283 'wavelength',
4284 'lightSource|LightSourceWrapper',
4285 'microbeamManipulation',
4286 'version')
4287
4290
4291 LightSettingsWrapper = _LightSettingsWrapper
4294 """
4295 base Light Source class wrapper, extends BlitzObjectWrapper.
4296 """
4297 _attrs = ('manufacturer',
4298 'model',
4299 'power',
4300 'serialNumber',
4301 '#type;lightSourceType',
4302 'version')
4303
4305 rv = self.type
4306 if self.type is not None:
4307 rv = EnumerationWrapper(self._conn, self.type)
4308 if not self.type.loaded:
4309 self.type = rv._obj
4310 return rv
4311
4312 _LightSourceClasses = {}
4318
4320 """
4321 omero_model_ArcI class wrapper extends LightSourceWrapper.
4322 """
4323
4327
4328 FilamentWrapper = _FilamentWrapper
4329 _LightSourceClasses[omero.model.FilamentI] = 'FilamentWrapper'
4332 """
4333 omero_model_ArcI class wrapper extends FilamentWrapper.
4334 """
4338
4339 ArcWrapper = _ArcWrapper
4340 _LightSourceClasses[omero.model.ArcI] = 'ArcWrapper'
4343 """
4344 omero_model_LaserI class wrapper extends LightSourceWrapper.
4345 """
4347 super(self.__class__, self).__bstrap__()
4348 self.OMERO_CLASS = 'Laser'
4349 self._attrs += (
4350 '#laserMedium',
4351 'frequencyMultiplication',
4352 'tuneable',
4353 'pulse',
4354 'wavelength',
4355 'pockelCell',
4356 'pump',
4357 'repetitionRate')
4358
4360 rv = self.laserMedium
4361 if self.laserMedium is not None:
4362 rv = EnumerationWrapper(self._conn, self.laserMedium)
4363 if not self.laserMedium.loaded:
4364 self.laserMedium = rv._obj
4365 return rv
4366
4367 LaserWrapper = _LaserWrapper
4368 _LightSourceClasses[omero.model.LaserI] = 'LaserWrapper'
4371 """
4372 omero_model_LightEmittingDiodeI class wrapper extends LightSourceWrapper.
4373 """
4377
4378 LightEmittingDiodeWrapper = _LightEmittingDiodeWrapper
4379 _LightSourceClasses[omero.model.LightEmittingDiodeI] = 'LightEmittingDiodeWrapper'
4382 """
4383 omero_model_MicroscopeI class wrapper extends BlitzObjectWrapper.
4384 """
4385 _attrs = ('manufacturer',
4386 'model',
4387 'serialNumber',
4388 '#type;microscopeType',
4389 'version')
4390
4393
4395 rv = self.type
4396 if self.type is not None:
4397 rv = EnumerationWrapper(self._conn, self.type)
4398 if not self.type.loaded:
4399 self.type = rv._obj
4400 return rv
4401
4402 MicroscopeWrapper = _MicroscopeWrapper
4405 """
4406 omero_model_InstrumentI class wrapper extends BlitzObjectWrapper.
4407 """
4408
4409
4410
4411 _attrs = ('microscope|MicroscopeWrapper',)
4412
4415
4417 if self._obj.microscope is not None:
4418 return MicroscopeWrapper(self._conn, self._obj.microscope)
4419 return None
4420
4422 return [DetectorWrapper(self._conn, x) for x in self._detectorSeq]
4423
4425 return [ObjectiveWrapper(self._conn, x) for x in self._objectiveSeq]
4426
4428 return [FilterWrapper(self._conn, x) for x in self._filterSeq]
4429
4431 return [DichroicWrapper(self._conn, x) for x in self._dichroicSeq]
4432
4434 return [FilterSetWrapper(self._conn, x) for x in self._filterSetSeq]
4435
4437 return [OTFWrapper(self._conn, x) for x in self._otfSeq]
4438
4441
4442
4456
4457 InstrumentWrapper = _InstrumentWrapper
4458