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 total space in bytes for this file system
1699 including nested subdirectories. """
1700
1701 rep_serv = self.getRepositoryInfoService()
1702 return rep_serv.getUsedSpaceInKilobytes() * 1024
1703
1705 """ Returns the free or available space on this file system
1706 including nested subdirectories. """
1707
1708 rep_serv = self.getRepositoryInfoService()
1709 return rep_serv.getFreeSpaceInKilobytes() * 1024
1710
1712 """ Returns list of users and how much space each of them use."""
1713
1714 query_serv = self.getQueryService()
1715 usage = dict()
1716 if self.getUser().isAdmin():
1717 admin_serv = self.getAdminService()
1718 groups = admin_serv.lookupGroups()
1719 for group in groups:
1720 for gem in group.copyGroupExperimenterMap():
1721 exp = gem.child
1722 res = query_serv.projection("""
1723 select o.id, sum(p.sizeX * p.sizeY * p.sizeZ * p.sizeC * p.sizeT), p.pixelsType.value
1724 from Pixels p join p.details.owner o
1725 group by o.id, p.pixelsType.value
1726 """, None, {"omero.group":str(group.id.val)})
1727 rv = unwrap(res)
1728 for r in rv:
1729 if usage.has_key(r[0]):
1730 usage[r[0]] += r[1]*self.bytesPerPixel(r[2])
1731 else:
1732 usage[r[0]] = r[1]*self.bytesPerPixel(r[2])
1733 else:
1734 groups = self.getEventContext().memberOfGroups
1735 groups.extend(self.getEventContext().leaderOfGroups)
1736 groups = set(groups)
1737 for gid in groups:
1738 res = query_serv.projection("""
1739 select o.id, sum(p.sizeX * p.sizeY * p.sizeZ * p.sizeC * p.sizeT), p.pixelsType.value
1740 from Pixels p join p.details.owner o
1741 group by o.id, p.pixelsType.value
1742 """, None, {"omero.group":str(gid)})
1743 rv = unwrap(res)
1744 for r in rv:
1745 if usage.has_key(gid):
1746 usage[gid] += r[1]*self.bytesPerPixel(r[2])
1747 else:
1748 usage[gid] = r[1]*self.bytesPerPixel(r[2])
1749 return usage
1750
1752 if pixel_type == "int8" or pixel_type == "uint8":
1753 return 1
1754 elif pixel_type == "int16" or pixel_type == "uint16":
1755 return 2
1756 elif pixel_type == "int32" or pixel_type == "uint32" or pixel_type == "float":
1757 return 4
1758 elif pixel_type == "double":
1759 return 8;
1760 else:
1761 logger.error("Error: Unknown pixel type: %s" % (pixel_type))
1762 logger.error(traceback.format_exc())
1763 raise AttributeError("Unknown pixel type: %s" % (pixel_type))
1764
1765
1766
1767
1769 """ Gets all owned shares for the current user. """
1770
1771 sh = self.getShareService()
1772 for e in sh.getOwnShares(False):
1773 yield ShareWrapper(self, e)
1774
1776 """ Gets all shares where current user is a member. """
1777
1778 sh = self.getShareService()
1779 for e in sh.getMemberShares(False):
1780 yield ShareWrapper(self, e)
1781
1783 """ Returns a map from share id to the count of total members (including the
1784 owner). This is represented by ome.model.meta.ShareMember links."""
1785
1786 sh = self.getShareService()
1787 return sh.getMemberCount(share_ids)
1788
1794
1795 - def getContents(self, share_id):
1796 """ Looks up all items belong to the share."""
1797
1798 sh = self.getShareService()
1799 for e in sh.getContents(long(share_id)):
1800 yield ShareContentWrapper(self, e)
1801
1808
1810 """ Get all {@link Experimenter users} who are a member of the share."""
1811
1812 sh = self.getShareService()
1813 for e in sh.getAllMembers(long(share_id)):
1814 yield ExperimenterWrapper(self, e)
1815
1817 """ Get the email addresses for all share guests."""
1818
1819 sh = self.getShareService()
1820 return sh.getAllGuests(long(share_id))
1821
1823 """ Get a single set containing the login names of the users as well email addresses for guests."""
1824
1825 sh = self.getShareService()
1826 return sh.getAllUsers(long(share_id))
1827
1828
1829
1830
1832 """
1833 List images based on the their creation times.
1834 If both tfrom and tto are None, grab the most recent batch.
1835
1836 @param tfrom: milliseconds since the epoch for start date
1837 @param tto: milliseconds since the epoch for end date
1838 @param tlimit: maximum number of results
1839 @param only_owned: Only owned by the logged user. Boolean.
1840 @return: Generator yielding _ImageWrapper
1841 """
1842 tm = self.getTimelineService()
1843 p = omero.sys.Parameters()
1844 f = omero.sys.Filter()
1845 if only_owned:
1846 f.ownerId = rlong(self.getEventContext().userId)
1847 f.groupId = rlong(self.getEventContext().groupId)
1848 else:
1849 f.ownerId = rlong(-1)
1850 f.groupId = None
1851 f.limit = rint(limit)
1852 p.theFilter = f
1853 if tfrom is None and tto is None:
1854 for e in tm.getMostRecentObjects(['Image'], p, False)["Image"]:
1855 yield ImageWrapper(self, e)
1856 else:
1857 if tfrom is None:
1858 tfrom = 0
1859 if tto is None:
1860 tto = time.time() * 1000
1861 for e in tm.getByPeriod(['Image'], rtime(long(tfrom)), rtime(long(tto)), p, False)['Image']:
1862 yield ImageWrapper(self, e)
1863
1864
1865
1866
1867
1869 """
1870 Return Project for the given ID.
1871
1872 @param oid: Project ID.
1873 @return: _ProjectWrapper or None
1874 """
1875
1876 q = self.getQueryService()
1877 pr = q.find("Project", long(oid))
1878 if pr is not None:
1879 pr = ProjectWrapper(self, pr)
1880 return pr
1881
1883 """
1884 Return Project with the given name.
1885
1886 @param name: Project name.
1887 @return: _ProjectWrapper or None
1888 """
1889 q = self.getQueryService()
1890 params = omero.sys.Parameters()
1891 if not params.map:
1892 params.map = {}
1893 params.map['name'] = rstring(name)
1894 pr = q.findAllByQuery("from Project as p where p.name=:name", params)
1895 if len(pr):
1896 return ProjectWrapper(self, pr[0])
1897 return None
1898
1900 """
1901 Return Dataset for the given ID.
1902
1903 @param oid: Dataset ID.
1904 @return: _DatasetWrapper or None
1905 """
1906
1907 q = self.getQueryService()
1908 ds = q.find("Dataset", long(oid))
1909 if ds is not None:
1910 ds = DatasetWrapper(self, ds)
1911 return ds
1912
1914 """
1915 Return Image for the given ID.
1916
1917 @param oid: Image ID.
1918 @return: _ImageWrapper or None
1919 """
1920
1921 q = self.getQueryService()
1922 img = q.find("Image", long(oid))
1923 if img is not None:
1924 img = ImageWrapper(self, img)
1925 return img
1926
1928 """ Gets share for the given share id. """
1929
1930 sh_serv = self.getShareService()
1931 sh = sh_serv.getShare(long(oid))
1932 if sh is not None:
1933 return ShareWrapper(self, sh)
1934 else:
1935 return None
1936
1938 query_serv = self.getQueryService()
1939 p = omero.sys.Parameters()
1940 p.map = {}
1941 p.map["oid"] = rlong(long(oid))
1942 sql = "select sc from Screen sc join fetch sc.details.owner join fetch sc.details.group where sc.id=:oid "
1943 sc = query_serv.findByQuery(sql,p)
1944 if sc is not None:
1945 return ScreenWrapper(self, sc)
1946 else:
1947 return None
1948
1950 query_serv = self.getQueryService()
1951 p = omero.sys.Parameters()
1952 p.map = {}
1953 p.map["oid"] = rlong(long(oid))
1954 sql = "select pl from Plate pl join fetch pl.details.owner join fetch pl.details.group " \
1955 "left outer join fetch pl.screenLinks spl " \
1956 "left outer join fetch spl.parent sc where pl.id=:oid "
1957 pl = query_serv.findByQuery(sql,p)
1958 if pl is not None:
1959 return PlateWrapper(self, pl)
1960 else:
1961 return None
1962
1964 query_serv = self.getQueryService()
1965 p = omero.sys.Parameters()
1966 p.map = {}
1967 p.map["ids"] = rlist([rlong(a) for a in oids])
1968 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"
1969 for e in query_serv.findAllByQuery(sql, p):
1970 yield ImageWrapper(self, e)
1971
1973 query_serv = self.getQueryService()
1974 p = omero.sys.Parameters()
1975 p.map = {}
1976 p.map["ids"] = rlist([rlong(a) for a in oids])
1977 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"
1978 for e in query_serv.findAllByQuery(sql, p):
1979 yield DatasetWrapper(self, e)
1980
1982 query_serv = self.getQueryService()
1983 p = omero.sys.Parameters()
1984 p.map = {}
1985 p.map["ids"] = rlist([rlong(a) for a in oids])
1986 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"
1987 for e in query_serv.findAllByQuery(sql, p):
1988 yield ProjectWrapper(self, e)
1989
1991 query_serv = self.getQueryService()
1992 p = omero.sys.Parameters()
1993 p.map = {}
1994 p.map["ids"] = rlist([rlong(a) for a in oids])
1995 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"
1996 for e in query_serv.findAllByQuery(sql, p):
1997 yield DatasetWrapper(self, e)
1998
1999
2000
2001
2003 query_serv = self.getQueryService()
2004 p = omero.sys.Parameters()
2005 p.map = {}
2006 p.map["oid"] = rlong(long(oid))
2007 sql = "select f from FileAnnotation f join fetch f.file where f.id = :oid"
2008 of = query_serv.findByQuery(sql, p)
2009 return FileAnnotationWrapper(self, of)
2010
2019
2021 query_serv = self.getQueryService()
2022 p = omero.sys.Parameters()
2023 p.map = {}
2024 p.map["oid"] = rlong(long(oid))
2025 sql = "select tg from TagAnnotation tg where tg.id = :oid"
2026 tg = query_serv.findByQuery(sql, p)
2027 return AnnotationWrapper(self, tg)
2028
2030 query_serv = self.getQueryService()
2031 p = omero.sys.Parameters()
2032 p.map = {}
2033 p.map["text"] = rstring(str(name))
2034 p.map["eid"] = rlong(self.getEventContext().userId)
2035 f = omero.sys.Filter()
2036 f.limit = rint(1)
2037 p.theFilter = f
2038 sql = "select tg from TagAnnotation tg " \
2039 "where tg.textValue=:text and tg.details.owner.id=:eid and tg.ns is null order by tg.textValue"
2040 tg = query_serv.findByQuery(sql, p)
2041 return AnnotationWrapper(self, tg)
2042
2043
2044
2045
2047 """
2048 TODO: description
2049
2050 @return: Generator yielding _ImageWrapper
2051 """
2052
2053 if not params:
2054 params = omero.sys.Parameters()
2055 if not params.map:
2056 params.map = {}
2057 params.map["ns"] = omero_type(ns)
2058 query = """
2059 select i
2060 from Image i
2061 join i.annotationLinks ial
2062 join ial.child as a
2063 where a.ns = :ns
2064 order by a.id desc """
2065 for i in self.getQueryService().findAllByQuery(query, params):
2066 yield ImageWrapper(self, i)
2067
2068
2069
2070
2071
2073 types = self.getTypesService()
2074 for e in types.allEnumerations(str(klass)):
2075 yield EnumerationWrapper(self, e)
2076
2078 types = self.getTypesService()
2079 obj = types.getEnumeration(str(klass), str(string))
2080 if obj is not None:
2081 return EnumerationWrapper(self, obj)
2082 else:
2083 return None
2084
2086 query_serv = self.getQueryService()
2087 obj = query_serv.find(klass, long(eid))
2088 if obj is not None:
2089 return EnumerationWrapper(self, obj)
2090 else:
2091 return None
2092
2101
2103 types = self.getTypesService()
2104 return types.getEnumerationTypes()
2105
2115
2119
2123
2127
2131
2132
2133
2134
2138
2144
2146 op = dict()
2147 if anns is None:
2148 op["/TagAnnotation"] = "KEEP"
2149 op["/TermAnnotation"] = "KEEP"
2150 op["/FileAnnotation"] = "KEEP"
2151 dc = omero.api.delete.DeleteCommand('/Image', long(oid), op)
2152 handle = self.getDeleteService().queueDelete([dc])
2153 return handle
2154
2156 op = dict()
2157 if anns is None:
2158 op["/TagAnnotation"] = "KEEP"
2159 op["/TermAnnotation"] = "KEEP"
2160 op["/FileAnnotation"] = "KEEP"
2161 dcs = list()
2162 for i in ids:
2163 dcs.append(omero.api.delete.DeleteCommand('/Image', long(i), op))
2164 handle = self.getDeleteService().queueDelete(dcs)
2165 return handle
2166
2168 op = dict()
2169 if anns is None:
2170 op["/TagAnnotation"] = "KEEP"
2171 op["/TermAnnotation"] = "KEEP"
2172 op["/FileAnnotation"] = "KEEP"
2173 dc = omero.api.delete.DeleteCommand('/Plate', long(oid), op)
2174 handle = self.getDeleteService().queueDelete([dc])
2175 return handle
2176
2178 op = dict()
2179 if anns is None:
2180 op["/TagAnnotation"] = "KEEP"
2181 op["/TermAnnotation"] = "KEEP"
2182 op["/FileAnnotation"] = "KEEP"
2183 if child is None:
2184 op["/Image"] = "KEEP"
2185 dc = omero.api.delete.DeleteCommand('/Dataset', long(obj.id), op)
2186 handle = self.getDeleteService().queueDelete([dc])
2187 return handle
2188
2190 op = dict()
2191 if anns is None:
2192 op["/TagAnnotation"] = "KEEP"
2193 op["/TermAnnotation"] = "KEEP"
2194 op["/FileAnnotation"] = "KEEP"
2195 if child is None:
2196 op["/Dataset"] = "KEEP"
2197 op["/Image"] = "KEEP"
2198 dc = omero.api.delete.DeleteCommand('/Project', long(obj.id), op)
2199 handle = self.getDeleteService().queueDelete([dc])
2200 return handle
2201
2203 op = dict()
2204 if anns is None:
2205 op["/TagAnnotation"] = "KEEP"
2206 op["/TermAnnotation"] = "KEEP"
2207 op["/FileAnnotation"] = "KEEP"
2208 if child is None:
2209 op["/Plate"] = "KEEP"
2210 dc = omero.api.delete.DeleteCommand('/Screen', long(obj.id), op)
2211 handle = self.getDeleteService().queueDelete([dc])
2212 return handle
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2225 search = self.createSearchService()
2226 search.onlyType('Image')
2227 search.addOrderByAsc("name")
2228 if created:
2229 search.onlyCreatedBetween(created[0], created[1]);
2230 if text:
2231 search.setAllowLeadingWildcard(True)
2232 search.byFullText(str(text))
2233 if search.hasNext():
2234 for e in search.results():
2235 yield ImageWrapper(self, e)
2236
2238 search = self.createSearchService()
2239 search.onlyType('Dataset')
2240 search.addOrderByAsc("name")
2241 if created:
2242 search.onlyCreatedBetween(created[0], created[1]);
2243 if text:
2244 search.setAllowLeadingWildcard(True)
2245 search.byFullText(str(text))
2246
2247 if search.hasNext():
2248 for e in search.results():
2249 yield DatasetWrapper(self, e)
2250
2251
2253 search = self.createSearchService()
2254 search.onlyType('Project')
2255 search.addOrderByAsc("name")
2256 if created:
2257 search.onlyCreatedBetween(created[0], created[1]);
2258 if text:
2259 search.setAllowLeadingWildcard(True)
2260 search.byFullText(str(text))
2261 if search.hasNext():
2262 for e in search.results():
2263 yield ProjectWrapper(self, e)
2264
2266 search = self.createSearchService()
2267 search.onlyType('Screen')
2268 search.addOrderByAsc("name")
2269 if created:
2270 search.onlyCreatedBetween(created[0], created[1]);
2271 if text:
2272 search.setAllowLeadingWildcard(True)
2273 search.byFullText(str(text))
2274 if search.hasNext():
2275 for e in search.results():
2276 yield ScreenWrapper(self, e)
2277
2279 search = self.createSearchService()
2280 search.onlyType('Plate')
2281 search.addOrderByAsc("name")
2282 if created:
2283 search.onlyCreatedBetween(created[0], created[1]);
2284 if text:
2285 search.setAllowLeadingWildcard(True)
2286 search.byFullText(str(text))
2287 if search.hasNext():
2288 for e in search.results():
2289 yield PlateWrapper(self, e)
2290
2292 """
2293 Fulltext search on Projects, Datasets and Images.
2294 TODO: search other object types?
2295 TODO: batch support.
2296 """
2297 if not text:
2298 return []
2299 if isinstance(text, UnicodeType):
2300 text = text.encode('utf8')
2301 if types is None:
2302 types = (ProjectWrapper, DatasetWrapper, ImageWrapper)
2303 search = self.createSearchService()
2304 if text[0] in ('?','*'):
2305 search.setAllowLeadingWildcard(True)
2306 rv = []
2307 for t in types:
2308 def actualSearch ():
2309 search.onlyType(t().OMERO_CLASS)
2310 search.byFullText(text)
2311 timeit(actualSearch)()
2312 if search.hasNext():
2313 def searchProcessing ():
2314 rv.extend(map(lambda x: t(self, x), search.results()))
2315 timeit(searchProcessing)()
2316 search.close()
2317 return rv
2318
2320 """
2321 Captures called function. Throws an exception.
2322
2323 @return:
2324 """
2325
2326 def inner (*args, **kwargs):
2327 try:
2328 return f(*args, **kwargs)
2329 except omero.ResourceError:
2330 logger.debug('captured resource error')
2331 raise
2332 except omero.SecurityViolation:
2333 raise
2334 except omero.ApiUsageException:
2335 raise
2336 except Ice.MemoryLimitException:
2337 raise
2338 except omero.InternalException:
2339 raise
2340 except Ice.Exception, x:
2341
2342 logger.debug( "Ice.Exception (1) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs)))
2343 logger.debug(traceback.format_exc())
2344
2345 try:
2346 self._obj = self._create_func()
2347 func = getattr(self._obj, attr)
2348 return func(*args, **kwargs)
2349 except Ice.MemoryLimitException:
2350 raise
2351 except Ice.Exception, x:
2352
2353 logger.debug("Ice.Exception (2) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs)))
2354 logger.debug(traceback.format_exc())
2355 try:
2356
2357 self._connect()
2358 logger.debug('last try for %s' % attr)
2359
2360 func = getattr(self._obj, attr)
2361 return func(*args, **kwargs)
2362 except:
2363 raise
2364
2365 def wrapped (*args, **kwargs):
2366 try:
2367 return inner(*args, **kwargs)
2368 except Ice.MemoryLimitException:
2369 logger.debug("MemoryLimitException! abort, abort...")
2370 raise
2371 except omero.SecurityViolation:
2372 logger.debug("SecurityViolation, bailing out")
2373 raise
2374 except omero.ApiUsageException:
2375 logger.debug("ApiUsageException, bailing out")
2376 raise
2377 except Ice.UnknownException:
2378 logger.debug("UnknownException, bailing out")
2379 raise
2380 except Ice.Exception, x:
2381 logger.debug('wrapped ' + f.func_name)
2382 logger.debug(x.__dict__)
2383 if x.serverExceptionClass == 'ome.conditions.InternalException':
2384 if x.message.find('java.lang.NullPointerException') > 0:
2385 logger.debug("NullPointerException, bailing out")
2386 raise
2387 elif x.message.find('Session is dirty') >= 0:
2388 logger.debug("Session is dirty, bailing out")
2389 raise
2390 else:
2391 logger.debug(x.message)
2392 logger.debug("exception caught, first time we back off for 10 secs")
2393 logger.debug(traceback.format_exc())
2394
2395 return inner(*args, **kwargs)
2396 return wrapped
2397
2398
2399 BlitzGateway = _BlitzGateway
2403 """ splits an hex stream of characters into an array of bytes in format (R,G,B,A).
2404 - abc -> (0xAA, 0xBB, 0xCC, 0xFF)
2405 - abcd -> (0xAA, 0xBB, 0xCC, 0xDD)
2406 - abbccd -> (0xAB, 0xBC, 0xCD, 0xFF)
2407 - abbccdde -> (0xAB, 0xBC, 0xCD, 0xDE)
2408 """
2409 try:
2410 out = []
2411 if len(color) in (3,4):
2412 c = color
2413 color = ''
2414 for e in c:
2415 color += e + e
2416 if len(color) == 6:
2417 color += 'FF'
2418 if len(color) == 8:
2419 for i in range(0, 8, 2):
2420 out.append(int(color[i:i+2], 16))
2421 return out
2422 except:
2423 pass
2424 return None
2425
2429 self._obj = None
2430 self._func_str = func_str
2431 self._resyncConn(conn)
2432 self._tainted = False
2433
2436
2438 """
2439 Returns True if connected.
2440
2441 @return: Boolean
2442 """
2443
2444 logger.debug("proxy_connect: a");
2445 if not self._conn.connect():
2446 logger.debug('connect failed')
2447 logger.debug('/n'.join(traceback.format_stack()))
2448 return False
2449 logger.debug("proxy_connect: b");
2450 self._resyncConn(self._conn)
2451 logger.debug("proxy_connect: c");
2452 self._obj = self._create_func()
2453 logger.debug("proxy_connect: d");
2454 return True
2455
2457 self._tainted = True
2458
2460 self._tainted = False
2461
2463 """
2464 Closes the underlaying service, so next call to the proxy will create a new
2465 instance of it.
2466 """
2467 if self._obj and isinstance(self._obj, omero.api.StatefulServiceInterfacePrx):
2468 self._obj.close()
2469 self._obj = None
2470
2472 """
2473
2474 @param conn: Connection
2475 """
2476
2477 self._conn = conn
2478 self._sf = conn.c.sf
2479 self._create_func = getattr(self._sf, self._func_str)
2480 if self._obj is not None:
2481 try:
2482 logger.debug("## - refreshing %s" % (self._func_str))
2483 obj = conn.c.ic.stringToProxy(str(self._obj))
2484 self._obj = self._obj.checkedCast(obj)
2485 except Ice.ObjectNotExistException:
2486 self._obj = None
2487
2489 """
2490
2491 @return: obj
2492 """
2493 if not self._obj:
2494 self._obj = self._create_func()
2495 else:
2496 self._ping()
2497 return self._obj
2498
2500 """
2501 For some reason, it seems that keepAlive doesn't, so every so often I need to recreate the objects.
2502
2503 @return: Boolean
2504 """
2505
2506 try:
2507 if not self._sf.keepAlive(self._obj):
2508 logger.debug("... died, recreating ...")
2509 self._obj = self._create_func()
2510 except Ice.ObjectNotExistException:
2511
2512 logger.debug("... reset, reconnecting")
2513 self._connect()
2514 return False
2515 except Ice.ConnectionLostException:
2516
2517 logger.debug(traceback.format_stack())
2518 logger.debug("... lost, reconnecting")
2519 self._conn._connected = False
2520 self._connect()
2521 return False
2522 except Ice.ConnectionRefusedException:
2523
2524 logger.debug(traceback.format_stack())
2525 logger.debug("... refused, reconnecting")
2526 self._connect()
2527 return False
2528 except omero.RemovedSessionException:
2529
2530 logger.debug(traceback.format_stack())
2531 logger.debug("... session has left the building, reconnecting")
2532 self._connect()
2533 return False
2534 except Ice.UnknownException:
2535
2536 logger.debug(traceback.format_stack())
2537 logger.debug("... ice says something bad happened, reconnecting")
2538 self._connect()
2539 return False
2540 return True
2541
2543 """
2544
2545 @param attr: Connection
2546 @return: rv
2547 """
2548
2549 obj = self._obj or self._getObj()
2550 rv = getattr(obj, attr)
2551 if callable(rv):
2552 rv = safeCallWrap(self, attr, rv)
2553
2554 return rv
2555
2558 """
2559 omero_model_AnnotationI class wrapper extends BlitzObjectWrapper.
2560 """
2561 registry = {}
2562 OMERO_TYPE = None
2563
2569
2572
2573 @classmethod
2576
2577 @classmethod
2578 - def _wrap (klass, conn, obj, link=None):
2579 if obj.__class__ in klass.registry:
2580 kwargs = dict()
2581 if link is not None:
2582 kwargs['link'] = BlitzObjectWrapper(conn, link)
2583 return klass.registry[obj.__class__](conn, obj, **kwargs)
2584 else:
2585 return None
2586
2587 @classmethod
2594
2596 return self._obj.ns is not None and self._obj.ns.val or None
2597
2600
2602 raise NotImplementedError
2603
2605 raise NotImplementedError
2606
2607 from omero_model_FileAnnotationI import FileAnnotationI
2610 """
2611 omero_model_FileAnnotatio class wrapper extends AnnotationWrapper.
2612 """
2613
2614 OMERO_TYPE = FileAnnotationI
2615
2619
2622
2625
2634
2637
2641
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672 AnnotationWrapper._register(FileAnnotationWrapper)
2673
2674 from omero_model_TimestampAnnotationI import TimestampAnnotationI
2677 """
2678 omero_model_TimestampAnnotatio class wrapper extends AnnotationWrapper.
2679 """
2680
2681 OMERO_TYPE = TimestampAnnotationI
2682
2684 return datetime.fromtimestamp(self._obj.timeValue.val / 1000.0)
2685
2687 if isinstance(val, datetime):
2688 self._obj.timeValue = rtime(long(time.mktime(val.timetuple())*1000))
2689 elif isinstance(val, omero.RTime):
2690 self._obj.timeValue = val
2691 else:
2692 self._obj.timeValue = rtime(long(val * 1000))
2693
2694 AnnotationWrapper._register(TimestampAnnotationWrapper)
2695
2696 from omero_model_BooleanAnnotationI import BooleanAnnotationI
2699 """
2700 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper.
2701 """
2702
2703 OMERO_TYPE = BooleanAnnotationI
2704
2706 return self._obj.boolValue.val
2707
2709 self._obj.boolValue = rbool(not not val)
2710
2711 AnnotationWrapper._register(BooleanAnnotationWrapper)
2712
2713 from omero_model_TagAnnotationI import TagAnnotationI
2716 """
2717 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper.
2718 """
2719
2720 OMERO_TYPE = TagAnnotationI
2721
2723 return self._obj.textValue.val
2724
2726 self._obj.textValue = rbool(not not val)
2727
2728 AnnotationWrapper._register(TagAnnotationWrapper)
2729
2730 from omero_model_CommentAnnotationI import CommentAnnotationI
2744
2745 AnnotationWrapper._register(CommentAnnotationWrapper)
2746
2747 from omero_model_LongAnnotationI import LongAnnotationI
2750 """
2751 omero_model_LongAnnotationI class wrapper extends AnnotationWrapper.
2752 """
2753 OMERO_TYPE = LongAnnotationI
2754
2756 return self._obj.longValue.val
2757
2759 self._obj.longValue = rlong(val)
2760
2761 AnnotationWrapper._register(LongAnnotationWrapper)
2762
2763 from omero_model_DoubleAnnotationI import DoubleAnnotationI
2766 """
2767 omero_model_DoubleAnnotationI class wrapper extends AnnotationWrapper.
2768 """
2769 OMERO_TYPE = DoubleAnnotationI
2770
2772 return self._obj.doubleValue.val
2773
2775 self._obj.doubleValue = rdouble(val)
2776
2777 AnnotationWrapper._register(DoubleAnnotationWrapper)
2778
2779 from omero_model_TermAnnotationI import TermAnnotationI
2782 """
2783 omero_model_TermAnnotationI class wrapper extends AnnotationWrapper.
2784 """
2785 OMERO_TYPE = TermAnnotationI
2786
2788 return self._obj.termValue.val
2789
2791 self._obj.termValue = rstring(val)
2792
2793 AnnotationWrapper._register(TermAnnotationWrapper)
2794
2795 from omero_model_XmlAnnotationI import XmlAnnotationI
2798 """
2799 omero_model_XmlAnnotationI class wrapper extends CommentAnnotationWrapper.
2800 """
2801 OMERO_TYPE = XmlAnnotationI
2802
2803 AnnotationWrapper._register(XmlAnnotationWrapper)
2806
2808 return self._obj.__class__
2809
2810 EnumerationWrapper = _EnumerationWrapper
2813 """
2814 omero_model_ExperimenterI class wrapper extends BlitzObjectWrapper.
2815 """
2816
2822
2824 rv = super(_ExperimenterWrapper, self).simpleMarshal(xtra=xtra, parents=parents)
2825 rv.update({'firstName': self.firstName,
2826 'middleName': self.middleName,
2827 'lastName': self.lastName,
2828 'email': self.email,
2829 'isAdmin': len(filter(lambda x: x.name.val == 'system', self._conn.getAdminService().containedGroups(self.getId()))) == 1,
2830 })
2831 return rv
2832
2834 """ Returns the experiments preferences annotation contents, as a ConfigParser instance """
2835 self._obj.unloadAnnotationLinks()
2836 cp = ConfigParser.SafeConfigParser()
2837 prefs = self.getAnnotation('TODO.changeme.preferences')
2838 if prefs is not None:
2839 prefs = prefs.getValue()
2840 if prefs is not None:
2841 cp.readfp(StringIO(prefs))
2842 return cp
2843
2845 """ Sets the experiments preferences annotation contents, passed in as a ConfigParser instance """
2846 ann = self.getAnnotation('TODO.changeme.preferences')
2847 t = StringIO()
2848 prefs.write(t)
2849 if ann is None:
2850 ann = CommentAnnotationWrapper()
2851 ann.setNs('TODO.changeme.preferences')
2852 ann.setValue(t.getvalue())
2853 self.linkAnnotation(ann)
2854 else:
2855 ann.setValue(t.getvalue())
2856 ann.save()
2857 self._obj.unloadAnnotationLinks()
2858
2860 if section is None:
2861 section = 'DEFAULT'
2862 try:
2863 return self.getRawPreferences().get(section, key)
2864 except ConfigParser.Error:
2865 return default
2866 return default
2867
2869 if section is None:
2870 section = 'DEFAULT'
2871 prefs = self.getRawPreferences()
2872 if prefs.has_section(section) or section == 'DEFAULT':
2873 return dict(prefs.items(section))
2874 return {}
2875
2884
2886 if not self._obj.details.owner:
2887 details = omero.model.DetailsI()
2888 details.owner = self._obj
2889 self._obj._details = details
2890 return DetailsWrapper(self._conn, self._obj.details)
2891
2894
2897
2899 """
2900 Gets full name of this experimenter.
2901
2902 @return: String or None
2903 """
2904
2905 try:
2906 if self.middleName is not None and self.middleName != '':
2907 name = "%s %s. %s" % (self.firstName, self.middleName[:1].upper(), self.lastName)
2908 else:
2909 name = "%s %s" % (self.firstName, self.lastName)
2910 except:
2911 logger.error(traceback.format_exc())
2912 name = self.omeName
2913 return name
2914
2916 try:
2917 if self.firstName is not None and self.lastName is not None:
2918 name = "%s. %s" % (self.firstName[:1], self.lastName)
2919 else:
2920 name = self.omeName
2921 except:
2922 logger.error(traceback.format_exc())
2923 name = self.omeName
2924 return name
2925
2927 for ob in self._obj.copyGroupExperimenterMap():
2928 if ob.parent.name.val == "system":
2929 return True
2930 return False
2931
2933 for ob in self._obj.copyGroupExperimenterMap():
2934 if ob.parent.name.val == "user":
2935 return True
2936 return False
2937
2939 for ob in self._obj.copyGroupExperimenterMap():
2940 if ob.parent.name.val == "guest":
2941 return True
2942 return False
2943
2944 ExperimenterWrapper = _ExperimenterWrapper
2947 """
2948 omero_model_ExperimenterGroupI class wrapper extends BlitzObjectWrapper.
2949 """
2950
2956
2961
2962 ExperimenterGroupWrapper = _ExperimenterGroupWrapper
2965 """
2966 omero_model_DetailsI class wrapper extends BlitzObjectWrapper.
2967 """
2968
2975
2978
2981
2983 """
2984 omero_model_DatasetI class wrapper extends BlitzObjectWrapper.
2985 """
2986
2992
2994 super(_DatasetWrapper, self).__loadedHotSwap__()
2995 if not self._obj.isImageLinksLoaded():
2996 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)
2997 self._obj._imageLinksLoaded = True
2998 self._obj._imageLinksSeq = links
2999
3000 DatasetWrapper = _DatasetWrapper
3003 """
3004 omero_model_ProjectI class wrapper extends BlitzObjectWrapper.
3005 """
3006
3012
3013 ProjectWrapper = _ProjectWrapper
3024
3025 ScreenWrapper = _ScreenWrapper
3036
3037 PlateWrapper = _PlateWrapper
3040
3046
3048 try:
3049 self.index = int(kwargs['index'])
3050 except:
3051 self.index = 0
3052
3054 """ return boolean if object exist """
3055 if getattr(self, 'isWellSamplesLoaded')():
3056 childnodes = getattr(self, 'copyWellSamples')()
3057 logger.debug('listChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3058 if len(childnodes) > 0:
3059 return True
3060 return False
3061
3063 """ return boolean if object exist """
3064 if getattr(self, 'isWellSamplesLoaded')():
3065 childnodes = getattr(self, 'copyWellSamples')()
3066 logger.debug('countChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3067 size = len(childnodes)
3068 if size > 0:
3069 return size
3070 return 0
3071
3073 """ return a wrapped child object """
3074 if getattr(self, 'isWellSamplesLoaded')():
3075 childnodes = getattr(self, 'copyWellSamples')()
3076 logger.debug('listSelectedChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3077 if len(childnodes) > 0:
3078 return WellSampleWrapper(self._conn, childnodes[self.index])
3079 return None
3080
3082 """ return a generator yielding child objects """
3083 if getattr(self, 'isWellSamplesLoaded')():
3084 childnodes = getattr(self, 'copyWellSamples')()
3085 logger.debug('listChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes)))
3086 for ch in childnodes:
3087 yield WellSampleWrapper(self._conn, ch)
3088
3090 return PlateWrapper(self._conn, self._obj.plate)
3091
3092 WellWrapper = _WellWrapper
3095
3100
3102 return ImageWrapper(self._conn, self._obj.image)
3103
3104 WellSampleWrapper = _WellSampleWrapper
3107
3109 return datetime.fromtimestamp(self.getStarted().val/1000)
3110
3112 try:
3113 return datetime.fromtimestamp((self.getStarted().val+self.getTimeToLive().val)/1000)
3114 except ValueError:
3115 pass
3116 return None
3117
3119 try:
3120 if (self.getStarted().val+self.getTimeToLive().val)/1000 <= time.time():
3121 return True
3122 else:
3123 return False
3124 except:
3125 return True
3126
3128 try:
3129 if self.owner.id.val == self._conn.getEventContext().userId:
3130 return True
3131 except:
3132 logger.error(traceback.format_exc())
3133 return False
3134
3136 return omero.gateway.ExperimenterWrapper(self, self.owner)
3137
3138 ShareWrapper = _ShareWrapper
3139
3140 -class ShareContentWrapper (BlitzObjectWrapper):
3142
3145
3149 """
3150 Stores color internally as (R,G,B,A) and allows setting and getting in multiple formats
3151 """
3152
3153 _color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255}
3154
3156 self._color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255}
3157 if colorname and colorname.lower() in self._color.keys():
3158 self._color[colorname.lower()] = 255
3159
3160 @classmethod
3168
3170 return self._color['red']
3171
3173 """
3174 Set red, as int 0..255
3175
3176 @param val: value of Red.
3177 """
3178
3179 self._color['red'] = max(min(255, int(val)), 0)
3180
3182 return self._color['green']
3183
3185 """
3186 Set green, as int 0..255
3187
3188 @param val: value of Green.
3189 """
3190
3191 self._color['green'] = max(min(255, int(val)), 0)
3192
3194 return self._color['blue']
3195
3197 """
3198 Set Blue, as int 0..255
3199
3200 @param val: value of Blue.
3201 """
3202
3203 self._color['blue'] = max(min(255, int(val)), 0)
3204
3206 return self._color['alpha']
3207
3209 """
3210 Set alpha, as int 0..255.
3211 @param val: value of alpha.
3212 """
3213
3214 self._color['alpha'] = max(min(255, int(val)), 0)
3215
3217 """
3218 @return: String. The html usable color. Dumps the alpha information.
3219 """
3220
3221 return "%(red)0.2X%(green)0.2X%(blue)0.2X" % (self._color)
3222
3224 """
3225 @return: String. rgba(r,g,b,a) for this color.
3226 """
3227
3228 c = self._color.copy()
3229 c['alpha'] /= 255.0
3230 return "rgba(%(red)i,%(green)i,%(blue)i,%(alpha)0.3f)" % (c)
3231
3233 """
3234 @return: list. A list of (r,g,b) values
3235 """
3236
3237 return (self._color['red'], self._color['green'], self._color['blue'])
3238
3240 """
3241 omero_model_LogicalChannelI class wrapper extends BlitzObjectWrapper.
3242 """
3243 _attrs = ('name',
3244 'pinHoleSize',
3245 '#illumination',
3246 'contrastMethod',
3247 'excitationWave',
3248 'emissionWave',
3249 'fluor',
3250 'ndFilter',
3251 'otf',
3252 'detectorSettings|DetectorSettingsWrapper',
3253 'lightSourceSettings|LightSettingsWrapper',
3254 'filterSet|FilterSetWrapper',
3255 'lightPath|LightPathWrapper',
3256 'samplesPerPixel',
3257 '#photometricInterpretation',
3258 'mode',
3259 'pockelCellSetting',
3260 'shapes',
3261 'version')
3262
3263 LogicalChannelWrapper = _LogicalChannelWrapper
3266 """
3267 base Light Source class wrapper, extends BlitzObjectWrapper.
3268 """
3269 _attrs = ('dichroic|DichroicWrapper')
3270
3271
3272
3275
3278
3281
3282 LightPathWrapper = _LightPathWrapper
3285 """
3286 omero_model_ChannelI class wrapper extends BlitzObjectWrapper.
3287 """
3288
3289 BLUE_MIN = 400
3290 BLUE_MAX = 500
3291 GREEN_MIN = 501
3292 GREEN_MAX = 600
3293 RED_MIN = 601
3294 RED_MAX = 700
3295 COLOR_MAP = ((BLUE_MIN, BLUE_MAX, ColorHolder('Blue')),
3296 (GREEN_MIN, GREEN_MAX, ColorHolder('Green')),
3297 (RED_MIN, RED_MAX, ColorHolder('Red')),
3298 )
3299
3302
3304 self._re = re
3305 self._idx = idx
3306 self._img = img
3307
3311
3314
3316 if self._obj.logicalChannel is not None:
3317 return LogicalChannelWrapper(self._conn, self._obj.logicalChannel)
3318
3320 lc = self.getLogicalChannel()
3321 rv = lc.name
3322 if rv is None:
3323 rv = lc.emissionWave
3324 if rv is None:
3325 rv = self._idx
3326 return rv
3327
3330
3332 return int(self._re.getChannelWindowStart(self._idx))
3333
3336
3338 return int(self._re.getChannelWindowEnd(self._idx))
3339
3342
3344 self._re.setChannelWindow(self._idx, float(minval), float(maxval))
3345
3347 return self._obj.getStatsInfo().getGlobalMin().val
3348
3350 return self._obj.getStatsInfo().getGlobalMax().val
3351
3352 ChannelWrapper = _ChannelWrapper
3355 def wrapped (self, *args, **kwargs):
3356 if not self._prepareRenderingEngine():
3357 return None
3358 return func(self, *args, **kwargs)
3359 return wrapped
3360
3362 def wrapped (self, *args, **kwargs):
3363 if not self._loadPixels():
3364 return None
3365 return func(self, *args, **kwargs)
3366 return wrapped
3367
3370 """
3371 omero_model_ImageI class wrapper extends BlitzObjectWrapper.
3372 """
3373
3374 _re = None
3375 _pd = None
3376 _rm = {}
3377 _pixels = None
3378
3379 _pr = None
3380
3381 PROJECTIONS = {
3382 'normal': -1,
3383 'intmax': omero.constants.projection.ProjectionType.MAXIMUMINTENSITY,
3384 'intmean': omero.constants.projection.ProjectionType.MEANINTENSITY,
3385 'intsum': omero.constants.projection.ProjectionType.SUMINTENSITY,
3386 }
3387
3388 PLANEDEF = omero.romio.XY
3389
3390 @classmethod
3397
3403
3406
3409
3411 i = self._obj.instrument
3412 if i is None:
3413 return None
3414 if not i.loaded:
3415 self._obj.instrument = self._conn.getQueryService().find('Instrument', i.id.val)
3416 i = self._obj.instrument
3417 meta_serv = self._conn.getMetadataService()
3418 instruments = meta_serv.loadInstrument(i.id.val)
3419
3420 if instruments._detectorLoaded:
3421 i._detectorSeq.extend(instruments._detectorSeq)
3422 if instruments._objectiveLoaded:
3423 i._objectiveSeq.extend(instruments._objectiveSeq)
3424 if instruments._lightSourceLoaded:
3425 i._lightSourceSeq.extend(instruments._lightSourceSeq)
3426 if instruments._filterLoaded:
3427 i._filterSeq.extend(instruments._filterSeq)
3428 if instruments._dichroicLoaded:
3429 i._dichroicSeq.extend(instruments._dichroicSeq)
3430 if instruments._filterSetLoaded:
3431 i._filterSetSeq.extend(instruments._filterSetSeq)
3432 if instruments._otfLoaded:
3433 i._otfSeq.extend(instruments._otfSeq)
3434
3435 return InstrumentWrapper(self._conn, i)
3436
3438 if not self._obj.pixelsLoaded:
3439 self.__loadedHotSwap__()
3440 return self._obj.sizeOfPixels() > 0
3441
3443 re = self._conn.createRenderingEngine()
3444 pixels_id = self._obj.getPrimaryPixels().id.val
3445 re.lookupPixels(pixels_id)
3446 if re.lookupRenderingDef(pixels_id) == False:
3447 try:
3448 re.resetDefaults()
3449 except omero.ResourceError:
3450
3451 return False
3452 re.lookupRenderingDef(pixels_id)
3453 re.load()
3454 return re
3455
3465
3472
3474 rv = super(_ImageWrapper, self).simpleMarshal(xtra=xtra, parents=parents)
3475 rv.update({'author': self.getAuthor(),
3476 'date': time.mktime(self.getDate().timetuple()),})
3477 if xtra:
3478 if xtra.has_key('thumbUrlPrefix'):
3479 if callable(xtra['thumbUrlPrefix']):
3480 rv['thumb_url'] = xtra['thumbUrlPrefix'](str(self.id))
3481 else:
3482 rv['thumb_url'] = xtra['thumbUrlPrefix'] + str(self.id) + '/'
3483 return rv
3484
3486 if self._obj.stageLabel is None:
3487 return None
3488 else:
3489 return ImageStageLabelWrapper(self._conn, self._obj.stageLabel)
3490
3492 name = self.name
3493 if not name:
3494 return ""
3495 l = len(name)
3496 if l < length+hist:
3497 return name
3498 return "..." + name[l - length:]
3499
3501 q = self._conn.getQueryService()
3502 e = q.findByQuery("select e from Experimenter e where e.id = %i" % self._obj.details.owner.id.val,None)
3503 self._author = e.firstName.val + " " + e.lastName.val
3504 return self._author
3505
3507 try:
3508 q = """
3509 select ds from Image i join i.datasetLinks dl join dl.parent ds
3510 where i.id = %i
3511 """ % self._obj.id.val
3512 query = self._conn.getQueryService()
3513 ds = query.findByQuery(q,None)
3514 return ds and DatasetWrapper(self._conn, ds) or None
3515 except:
3516 logger.debug('on getDataset')
3517 logger.debug(traceback.format_exc())
3518 return None
3519
3521 try:
3522 q = """
3523 select p from Image i join i.datasetLinks dl join dl.parent ds join ds.projectLinks pl join pl.parent p
3524 where i.id = %i
3525 """ % self._obj.id.val
3526 query = self._conn.getQueryService()
3527 prj = query.findByQuery(q,None)
3528 return prj and ProjectWrapper(self._conn, prj) or None
3529 except:
3530 logger.debug('on getProject')
3531 logger.debug(traceback.format_exc())
3532 return None
3533
3535 try:
3536 query = self._conn.getQueryService()
3537 event = query.findByQuery("select e from Event e where id = %i" % self._obj.details.creationEvent.id.val, None)
3538 return datetime.fromtimestamp(event.time.val / 1000)
3539 except:
3540 logger.debug('on getDate')
3541 logger.debug(traceback.format_exc())
3542
3543 return datetime.fromtimestamp(event.time.val / 1000)
3544
3546 rv = self.objectiveSettings
3547 if self.objectiveSettings is not None:
3548 rv = ObjectiveSettingsWrapper(self._conn, self.objectiveSettings)
3549 if not self.objectiveSettings.loaded:
3550 self.objectiveSettings = rv._obj
3551 return rv
3552
3554 rv = self.imagingEnvironment
3555 if self.imagingEnvironment is not None:
3556 rv = ImagingEnvironmentWrapper(self._conn, self.imagingEnvironment)
3557 if not self.imagingEnvironment.loaded:
3558 self.imagingEnvironment = rv._obj
3559 return rv
3560
3561 @assert_pixels
3564
3565 @assert_pixels
3568
3570 pixels_id = self.getPixelsId()
3571 if pixels_id is None:
3572 return None
3573 tb = self._conn.createThumbnailStore()
3574 try:
3575 rv = tb.setPixelsId(pixels_id)
3576 except omero.InternalException:
3577 logger.error(traceback.print_exc())
3578 rv = False
3579 if not rv:
3580 tb.resetDefaults()
3581 tb.close()
3582 tb.setPixelsId(pixels_id)
3583 return tb
3584
3613
3615 try:
3616 tb = self._prepareTB()
3617 if tb is None:
3618 return None
3619 if isinstance(size, IntType):
3620 size = (size,)
3621 if z is not None and t is not None:
3622 pos = z,t
3623 else:
3624 pos = None
3625 if len(size) == 1:
3626 if pos is None:
3627 thumb = tb.getThumbnailByLongestSideDirect
3628 else:
3629 thumb = tb.getThumbnailForSectionByLongestSideDirect
3630 else:
3631 if pos is None:
3632 thumb = tb.getThumbnailDirect
3633 else:
3634 thumb = tb.getThumbnailForSectionDirect
3635 args = map(lambda x: rint(x), size)
3636 if pos is not None:
3637 args = list(pos) + args
3638 rv = thumb(*args)
3639 return rv
3640 except Exception:
3641 logger.error(traceback.print_exc())
3642 return None
3643
3644 @assert_pixels
3646 """ Returns (min, max) values for the pixels type of this image.
3647 TODO: Does not handle floats correctly, though."""
3648 pixels_id = self._obj.getPrimaryPixels().getId().val
3649 rp = self._conn.createRawPixelsStore()
3650 rp.setPixelsId(pixels_id, True)
3651 pmax = 2 ** (8 * rp.getByteWidth())
3652 if rp.isSigned():
3653 return (-(pmax / 2), pmax / 2 - 1)
3654 else:
3655 return (0, pmax-1)
3656
3657 @assert_re
3659 return [ChannelWrapper(self._conn, c, idx=n, re=self._re, img=self) for n,c in enumerate(self._re.getPixels().iterateChannels())]
3660
3662 for c in range(len(self.getChannels())):
3663 self._re.setActive(c, (c+1) in channels)
3664 if (c+1) in channels:
3665 if windows is not None and windows[c][0] is not None and windows[c][1] is not None:
3666 self._re.setChannelWindow(c, *windows[c])
3667 if colors is not None and colors[c]:
3668 rgba = splitHTMLColor(colors[c])
3669 if rgba:
3670 self._re.setRGBA(c, *rgba)
3671 return True
3672
3675
3678
3679 LINE_PLOT_DTYPES = {
3680 (4, True, True): 'f',
3681 (2, False, False): 'H',
3682 (2, False, True): 'h',
3683 (1, False, False): 'B',
3684 (1, False, True): 'b',
3685 }
3686
3687 - def getPixelLine (self, z, t, pos, axis, channels=None, range=None):
3688 """
3689 Grab a horizontal or vertical line from the image pixel data, for the specified channels
3690 (or all if not specified) and using the specified range (or 1:1 relative to the image size).
3691 Axis may be 'h' or 'v', for horizontal or vertical respectively.
3692
3693 @param z:
3694 @param t:
3695 @param pos:
3696 @param axis:
3697 @param channels:
3698 @param range:
3699 @return: rv
3700 """
3701
3702 if not self._loadPixels():
3703 logger.debug( "No pixels!")
3704 return None
3705 axis = axis.lower()[:1]
3706 if channels is None:
3707 channels = map(lambda x: x._idx, filter(lambda x: x.isActive(), self.getChannels()))
3708 if range is None:
3709 range = axis == 'h' and self.getHeight() or self.getWidth()
3710 if not isinstance(channels, (TupleType, ListType)):
3711 channels = (channels,)
3712 chw = map(lambda x: (x.getWindowMin(), x.getWindowMax()), self.getChannels())
3713 rv = []
3714 pixels_id = self._obj.getPrimaryPixels().getId().val
3715 rp = self._conn.createRawPixelsStore()
3716 rp.setPixelsId(pixels_id, True)
3717 for c in channels:
3718 bw = rp.getByteWidth()
3719 key = self.LINE_PLOT_DTYPES.get((bw, rp.isFloat(), rp.isSigned()), None)
3720 if key is None:
3721 logger.error("Unknown data type: " + str((bw, rp.isFloat(), rp.isSigned())))
3722 plot = array.array(key, axis == 'h' and rp.getRow(pos, z, c, t) or rp.getCol(pos, z, c, t))
3723 plot.byteswap()
3724
3725 offset = -chw[c][0]
3726 if offset != 0:
3727 plot = map(lambda x: x+offset, plot)
3728 normalize = 1.0/chw[c][1]*(range-1)
3729 if normalize != 1.0:
3730 plot = map(lambda x: x*normalize, plot)
3731 if isinstance(plot, array.array):
3732 plot = plot.tolist()
3733 rv.append(plot)
3734 return rv
3735
3736
3737 - def getRow (self, z, t, y, channels=None, range=None):
3739
3740 - def getCol (self, z, t, x, channels=None, range=None):
3742
3743 @assert_re
3745 if not len(self._rm):
3746 for m in [BlitzObjectWrapper(self._conn, m) for m in self._re.getAvailableModels()]:
3747 self._rm[m.value.lower()] = m
3748 return self._rm.values()
3749
3750 @assert_re
3753
3755 """
3756 Sets the Greyscale rendering model on this image's current renderer
3757 """
3758
3759 rm = self.getRenderingModels()
3760 self._re.setModel(self._rm.get('greyscale', rm[0])._obj)
3761
3763 """
3764 Sets the HSB rendering model on this image's current renderer
3765 """
3766
3767 rm = self.getRenderingModels()
3768 self._re.setModel(self._rm.get('rgb', rm[0])._obj)
3769
3772
3773 @assert_re
3775 self._pd.z = long(z)
3776 self._pd.t = long(t)
3777 try:
3778 if compression is not None:
3779 try:
3780 self._re.setCompressionLevel(float(compression))
3781 except omero.SecurityViolation:
3782 self._obj.clearPixels()
3783 self._obj.pixelsLoaded = False
3784 self._re = None
3785 return self.renderJpeg(z,t,None)
3786 projection = self.PROJECTIONS.get(self._pr, -1)
3787 if not isinstance(projection, omero.constants.projection.ProjectionType):
3788 rv = self._re.renderCompressed(self._pd)
3789 else:
3790 rv = self._re.renderProjectedCompressed(projection, self._pd.t, 1, 0, self.z_count()-1)
3791 return rv
3792 except omero.InternalException:
3793 logger.debug('On renderJpeg');
3794 logger.debug(traceback.format_exc())
3795 return None
3796 except Ice.MemoryLimitException:
3797
3798 self._obj.clearPixels()
3799 self._obj.pixelsLoaded = False
3800 self._re = None
3801 raise
3802
3804 e = self._conn.createExporter()
3805 e.addImage(self.getId())
3806 size = e.generateTiff()
3807 p = 0
3808 rv = ''
3809 while p < size:
3810 s = min(65536, size-p)
3811 rv += e.read(p,s)
3812 p += s
3813 e.close()
3814 return rv
3815
3817 rv = self.renderJpeg(z,t,compression)
3818 if rv is not None:
3819 i = StringIO(rv)
3820 rv = Image.open(i)
3821 return rv
3822
3824 """
3825 Prepares a jpeg representation of a 2d grid holding a render of each channel,
3826 along with one for all channels at the set Z and T points.
3827
3828 @param z:
3829 @param t:
3830 @param compression:
3831 @param border:
3832 @return: value
3833 """
3834
3835 img = self.renderSplitChannelImage(z,t,compression, border)
3836 rv = StringIO()
3837 img.save(rv, 'jpeg', quality=int(compression*100))
3838 return rv.getvalue()
3839
3841 c = self.c_count()
3842
3843 x = sqrt(c)
3844 y = int(round(x))
3845 if x > y:
3846 x = y+1
3847 else:
3848 x = y
3849 rv = {'g':{'width': self.getWidth()*x + border*(x+1),
3850 'height': self.getHeight()*y+border*(y+1),
3851 'border': border,
3852 'gridx': x,
3853 'gridy': y,}
3854 }
3855
3856 c += 1
3857 x = sqrt(c)
3858 y = int(round(x))
3859 if x > y:
3860 x = y+1
3861 else:
3862 x = y
3863 rv['c'] = {'width': self.getWidth()*x + border*(x+1),
3864 'height': self.getHeight()*y+border*(y+1),
3865 'border': border,
3866 'gridx': x,
3867 'gridy': y,}
3868 return rv
3869
3871 """
3872 Prepares a PIL Image with a 2d grid holding a render of each channel,
3873 along with one for all channels at the set Z and T points.
3874
3875 @param z:
3876 @param t:
3877 @param compression:
3878 @param border:
3879 @return: canvas
3880 """
3881
3882 dims = self.splitChannelDims(border=border)[self.isGreyscaleRenderingModel() and 'g' or 'c']
3883 canvas = Image.new('RGBA', (dims['width'], dims['height']), '#fff')
3884 cmap = [ch.isActive() and i+1 or 0 for i,ch in enumerate(self.getChannels())]
3885 c = self.c_count()
3886 pxc = 0
3887 px = dims['border']
3888 py = dims['border']
3889
3890
3891 w = self.getWidth()
3892 if w >= 640:
3893 fsize = (int((w-640)/128)*8) + 24
3894 if fsize > 64:
3895 fsize = 64
3896 elif w >= 512:
3897 fsize = 24
3898 elif w >= 384:
3899 fsize = 18
3900 elif w >= 298:
3901 fsize = 14
3902 elif w >= 256:
3903 fsize = 12
3904 elif w >= 213:
3905 fsize = 10
3906 elif w >= 96:
3907 fsize = 8
3908 else:
3909 fsize = 0
3910 if fsize > 0:
3911 font = ImageFont.load('%s/pilfonts/B%0.2d.pil' % (THISPATH, fsize) )
3912
3913
3914 for i in range(c):
3915 if cmap[i]:
3916 self.setActiveChannels((i+1,))
3917 img = self.renderImage(z,t, compression)
3918 if fsize > 0:
3919 draw = ImageDraw.ImageDraw(img)
3920 draw.text((2,2), "%s" % (str(self.getChannels()[i].getEmissionWave())), font=font, fill="#fff")
3921 canvas.paste(img, (px, py))
3922 pxc += 1
3923 if pxc < dims['gridx']:
3924 px += self.getWidth() + border
3925 else:
3926 pxc = 0
3927 px = border
3928 py += self.getHeight() + border
3929 if not self.isGreyscaleRenderingModel():
3930 self.setActiveChannels(cmap)
3931 img = self.renderImage(z,t, compression)
3932 if fsize > 0:
3933 draw = ImageDraw.ImageDraw(img)
3934 draw.text((2,2), "merged", font=font, fill="#fff")
3935 canvas.paste(img, (px, py))
3936 return canvas
3937
3938 LP_PALLETE = [0,0,0,0,0,0,255,255,255]
3939 LP_TRANSPARENT = 0
3940 LP_BGCOLOR = 1
3941 LP_FGCOLOR = 2
3943 """
3944 Common part of horizontal and vertical line plot rendering.
3945 @returns: (Image, width, height).
3946 """
3947 channels = filter(lambda x: x.isActive(), self.getChannels())
3948 width = self.getWidth()
3949 height = self.getHeight()
3950
3951 pal = list(self.LP_PALLETE)
3952
3953 for channel in channels:
3954 pal.extend(channel.getColor().getRGB())
3955
3956
3957 im = Image.new('P', (width, height))
3958 im.putpalette(pal)
3959 return im, width, height
3960
3961
3962 @assert_re
3964 self._pd.z = long(z)
3965 self._pd.t = long(t)
3966
3967 im, width, height = self.prepareLinePlotCanvas(z,t)
3968 base = height - 1
3969
3970 draw = ImageDraw.ImageDraw(im)
3971
3972 draw.rectangle([0, 0, width-1, base], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT)
3973 draw.line(((0,y),(width, y)), fill=self.LP_FGCOLOR, width=linewidth)
3974
3975
3976 rows = self.getRow(z,t,y)
3977
3978 for r in range(len(rows)):
3979 chrow = rows[r]
3980 color = r + self.LP_FGCOLOR + 1
3981 last_point = base-chrow[0]
3982 for i in range(len(chrow)):
3983 draw.line(((i, last_point), (i, base-chrow[i])), fill=color, width=linewidth)
3984 last_point = base-chrow[i]
3985 del draw
3986 out = StringIO()
3987 im.save(out, format="gif", transparency=0)
3988 return out.getvalue()
3989
3990 @assert_re
3992 self._pd.z = long(z)
3993 self._pd.t = long(t)
3994
3995 im, width, height = self.prepareLinePlotCanvas(z,t)
3996
3997 draw = ImageDraw.ImageDraw(im)
3998
3999 draw.rectangle([0, 0, width-1, height-1], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT)
4000 draw.line(((x,0),(x, height)), fill=self.LP_FGCOLOR, width=linewidth)
4001
4002
4003 cols = self.getCol(z,t,x)
4004
4005 for r in range(len(cols)):
4006 chcol = cols[r]
4007 color = r + self.LP_FGCOLOR + 1
4008 last_point = chcol[0]
4009 for i in range(len(chcol)):
4010 draw.line(((last_point, i), (chcol[i], i)), fill=color, width=linewidth)
4011 last_point = chcol[i]
4012 del draw
4013 out = StringIO()
4014 im.save(out, format="gif", transparency=0)
4015 return out.getvalue()
4016
4017 @assert_re
4020
4021 @assert_re
4024
4025 @assert_pixels
4027 rv = self._obj.getPrimaryPixels().getPhysicalSizeX()
4028 return rv is not None and rv.val or 0
4029
4030 @assert_pixels
4032 rv = self._obj.getPrimaryPixels().getPhysicalSizeY()
4033 return rv is not None and rv.val or 0
4034
4035 @assert_pixels
4037 rv = self._obj.getPrimaryPixels().getPhysicalSizeZ()
4038 return rv is not None and rv.val or 0
4039
4040 @assert_pixels
4043
4044 @assert_pixels
4047
4048 @assert_pixels
4051
4052 @assert_pixels
4055
4056 @assert_pixels
4059
4061 """
4062 Removes specific color settings from channels
4063
4064 @return: Boolean
4065 """
4066
4067 if not self.canWrite():
4068 return False
4069 for c in self.getChannels():
4070 c.unloadRed()
4071 c.unloadGreen()
4072 c.unloadBlue()
4073 c.unloadAlpha()
4074 c.save()
4075 self._conn.getDeleteService().deleteSettings(self.getId())
4076 return True
4077
4078 @assert_re
4080 """
4081 Limited support for saving the current prepared image rendering defs.
4082 Right now only channel colors are saved back.
4083
4084 @return: Boolean
4085 """
4086
4087 if not self.canWrite():
4088 return False
4089 self._re.saveCurrentSettings()
4090 return True
4091
4092 ImageWrapper = _ImageWrapper
4098
4099 ImageStageLabelWrapper = _ImageStageLabelWrapper
4103
4104 ImagingEnvironmentWrapper = _ImagingEnvironmentWrapper
4107 """
4108 omero_model_ImagingEnvironmentI class wrapper extends BlitzObjectWrapper.
4109 """
4110 _attrs = ('temperature',
4111 'airPressure',
4112 'humidity',
4113 'co2percent',
4114 'version')
4115
4118
4119 ImagingEnviromentWrapper = _ImagingEnviromentWrapper
4122 """
4123 omero_model_TransmittanceRangeI class wrapper extends BlitzObjectWrapper.
4124 """
4125 _attrs = ('cutIn',
4126 'cutOut',
4127 'cutInTolerance',
4128 'cutOutTolerance',
4129 'transmittance',
4130 'version')
4131
4134
4135 TransmittanceRangeWrapper = _TransmittanceRangeWrapper
4138 """
4139 omero_model_DetectorSettingsI class wrapper extends BlitzObjectWrapper.
4140 """
4141 _attrs = ('voltage',
4142 'gain',
4143 'offsetValue',
4144 'readOutRate',
4145 'binning',
4146 'detector|DetectorWrapper',
4147 'version')
4148
4151
4152 DetectorSettingsWrapper = _DetectorSettingsWrapper
4155 """
4156 omero_model_DetectorI class wrapper extends BlitzObjectWrapper.
4157 """
4158 _attrs = ('manufacturer',
4159 'model',
4160 'serialNumber',
4161 'voltage',
4162 'gain',
4163 'offsetValue',
4164 'zoom',
4165 'amplificationGain',
4166 '#type;detectorType',
4167 'version')
4168
4171
4173 rv = self.type
4174 if self.type is not None:
4175 rv = EnumerationWrapper(self._conn, self.type)
4176 if not self.type.loaded:
4177 self.type = rv._obj
4178 return rv
4179
4180 DetectorWrapper = _DetectorWrapper
4183 """
4184 omero_model_ObjectiveI class wrapper extends BlitzObjectWrapper.
4185 """
4186 _attrs = ('manufacturer',
4187 'model',
4188 'serialNumber',
4189 'nominalMagnification',
4190 'calibratedMagnification',
4191 'lensNA',
4192 '#immersion',
4193 '#correction',
4194 'workingDistance',
4195 '#iris',
4196 'version')
4197
4200
4202 rv = self.immersion
4203 if self.immersion is not None:
4204 rv = EnumerationWrapper(self._conn, self.immersion)
4205 if not self.immersion.loaded:
4206 self.immersion = rv._obj
4207 return rv
4208
4210 rv = self.correction
4211 if self.correction is not None:
4212 rv = EnumerationWrapper(self._conn, self.correction)
4213 if not self.correction.loaded:
4214 self.correction = rv._obj
4215 return rv
4216
4218 rv = self.iris
4219 if self.iris is not None:
4220 rv = EnumerationWrapper(self._conn, self.iris)
4221 if not self.iris.loaded:
4222 self.iris = rv._obj
4223 return rv
4224
4225 ObjectiveWrapper = _ObjectiveWrapper
4228 """
4229 omero_model_ObjectiveSettingsI class wrapper extends BlitzObjectWrapper.
4230 """
4231 _attrs = ('correctionCollar',
4232 '#medium',
4233 'refractiveIndex',
4234 'objective|ObjectiveWrapper',
4235 'version')
4236
4239
4241 rv = self.objective
4242 if self.objective is not None:
4243 rv = ObjectiveWrapper(self._conn, self.objective)
4244 if not self.objective.loaded:
4245 self.objective = rv._obj
4246 return rv
4247
4249 rv = self.medium
4250 if self.medium is not None:
4251 rv = EnumerationWrapper(self._conn, self.medium)
4252 if not self.medium.loaded:
4253 self.medium = rv._obj
4254 return rv
4255
4256 ObjectiveSettingsWrapper = _ObjectiveSettingsWrapper
4260 """
4261 omero_model_FilterI class wrapper extends BlitzObjectWrapper.
4262 """
4263 _attrs = ('manufacturer',
4264 'model',
4265 'lotNumber',
4266 'filterWheel',
4267 '#type;filterType',
4268 'transmittanceRange|TransmittanceRangeWrapper',
4269 'version')
4270
4273
4275 rv = self.type
4276 if self.type is not None:
4277 rv = EnumerationWrapper(self._conn, self.type)
4278 if not self.type.loaded:
4279 self.type = rv._obj
4280 return rv
4281
4282 FilterWrapper = _FilterWrapper
4285 """
4286 omero_model_DichroicI class wrapper extends BlitzObjectWrapper.
4287 """
4288 _attrs = ('manufacturer',
4289 'model',
4290 'lotNumber',
4291 'version')
4292
4295
4296 DichroicWrapper = _DichroicWrapper
4299 """
4300 omero_model_FilterSetI class wrapper extends BlitzObjectWrapper.
4301 """
4302 _attrs = ('manufacturer',
4303 'model',
4304 'lotNumber',
4305
4306
4307 'dichroic|DichroicWrapper',
4308 'version')
4309
4312
4315
4318
4319 FilterSetWrapper = _FilterSetWrapper
4322 """
4323 omero_model_OTFI class wrapper extends BlitzObjectWrapper.
4324 """
4325 _attrs = ('sizeX',
4326 'sizeY',
4327 'opticalAxisAveraged'
4328 'pixelsType',
4329 'path',
4330 'filterSet|FilterSetWrapper',
4331 'objective|ObjectiveWrapper',
4332 'version')
4333
4336
4337 OTFWrapper = _OTFWrapper
4340 """
4341 base Light Source class wrapper, extends BlitzObjectWrapper.
4342 """
4343 _attrs = ('attenuation',
4344 'wavelength',
4345 'lightSource|LightSourceWrapper',
4346 'microbeamManipulation',
4347 'version')
4348
4351
4352 LightSettingsWrapper = _LightSettingsWrapper
4355 """
4356 base Light Source class wrapper, extends BlitzObjectWrapper.
4357 """
4358 _attrs = ('manufacturer',
4359 'model',
4360 'power',
4361 'serialNumber',
4362 '#type;lightSourceType',
4363 'version')
4364
4366 rv = self.type
4367 if self.type is not None:
4368 rv = EnumerationWrapper(self._conn, self.type)
4369 if not self.type.loaded:
4370 self.type = rv._obj
4371 return rv
4372
4373 _LightSourceClasses = {}
4379
4381 """
4382 omero_model_ArcI class wrapper extends LightSourceWrapper.
4383 """
4384
4388
4389 FilamentWrapper = _FilamentWrapper
4390 _LightSourceClasses[omero.model.FilamentI] = 'FilamentWrapper'
4393 """
4394 omero_model_ArcI class wrapper extends FilamentWrapper.
4395 """
4399
4400 ArcWrapper = _ArcWrapper
4401 _LightSourceClasses[omero.model.ArcI] = 'ArcWrapper'
4404 """
4405 omero_model_LaserI class wrapper extends LightSourceWrapper.
4406 """
4408 super(self.__class__, self).__bstrap__()
4409 self.OMERO_CLASS = 'Laser'
4410 self._attrs += (
4411 '#laserMedium',
4412 'frequencyMultiplication',
4413 'tuneable',
4414 'pulse',
4415 'wavelength',
4416 'pockelCell',
4417 'pump',
4418 'repetitionRate')
4419
4421 rv = self.laserMedium
4422 if self.laserMedium is not None:
4423 rv = EnumerationWrapper(self._conn, self.laserMedium)
4424 if not self.laserMedium.loaded:
4425 self.laserMedium = rv._obj
4426 return rv
4427
4428 LaserWrapper = _LaserWrapper
4429 _LightSourceClasses[omero.model.LaserI] = 'LaserWrapper'
4432 """
4433 omero_model_LightEmittingDiodeI class wrapper extends LightSourceWrapper.
4434 """
4438
4439 LightEmittingDiodeWrapper = _LightEmittingDiodeWrapper
4440 _LightSourceClasses[omero.model.LightEmittingDiodeI] = 'LightEmittingDiodeWrapper'
4443 """
4444 omero_model_MicroscopeI class wrapper extends BlitzObjectWrapper.
4445 """
4446 _attrs = ('manufacturer',
4447 'model',
4448 'serialNumber',
4449 '#type;microscopeType',
4450 'version')
4451
4454
4456 rv = self.type
4457 if self.type is not None:
4458 rv = EnumerationWrapper(self._conn, self.type)
4459 if not self.type.loaded:
4460 self.type = rv._obj
4461 return rv
4462
4463 MicroscopeWrapper = _MicroscopeWrapper
4466 """
4467 omero_model_InstrumentI class wrapper extends BlitzObjectWrapper.
4468 """
4469
4470
4471
4472 _attrs = ('microscope|MicroscopeWrapper',)
4473
4476
4478 if self._obj.microscope is not None:
4479 return MicroscopeWrapper(self._conn, self._obj.microscope)
4480 return None
4481
4483 return [DetectorWrapper(self._conn, x) for x in self._detectorSeq]
4484
4486 return [ObjectiveWrapper(self._conn, x) for x in self._objectiveSeq]
4487
4489 return [FilterWrapper(self._conn, x) for x in self._filterSeq]
4490
4492 return [DichroicWrapper(self._conn, x) for x in self._dichroicSeq]
4493
4495 return [FilterSetWrapper(self._conn, x) for x in self._filterSetSeq]
4496
4498 return [OTFWrapper(self._conn, x) for x in self._otfSeq]
4499
4502
4503
4517
4518 InstrumentWrapper = _InstrumentWrapper
4519