Package omero :: Package gateway
[hide private]
[frames] | no frames]

Source Code for Package omero.gateway

   1  # 
   2  # blitz_gateway - python bindings and wrappers to access an OMERO blitz server 
   3  #  
   4  # Copyright (c) 2007, 2010 Glencoe Software, Inc. All rights reserved. 
   5  #  
   6  # This software is distributed under the terms described by the LICENCE file 
   7  # you can find at the root of the distribution bundle, which states you are 
   8  # free to use it only for non commercial purposes. 
   9  # If the file is missing please request a copy by contacting 
  10  # jason@glencoesoftware.com. 
  11   
  12  # Set up the python include paths 
  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 # see ticket:2597 
  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 * 
47 48 -def omero_type(val):
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
72 -class TimeIt (object):
73 """ 74 Decorator to measure the execution time of a function. 75 76 @param level: the level to use for logging 77 """
78 - def __init__ (self, level=logging.DEBUG):
79 self._level = level
80
81 - def __call__ (self, func):
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
90 -def timeit (func):
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
105 106 107 108 -class BlitzObjectWrapper (object):
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
134 - def __eq__ (self, a):
135 return type(a) == type(self) and self._obj.id == a._obj.id and self.getName() == a.getName()
136
137 - def __bstrap__ (self):
138 pass
139
140 - def __prepare__ (self, **kwargs):
141 pass
142
143 - def __repr__ (self):
144 if hasattr(self, '_oid'): 145 return '<%s id=%s>' % (self.__class__.__name__, str(self._oid)) 146 return super(BlitzObjectWrapper, self).__repr__()
147
148 - def _getChildWrapper (self):
149 if self.CHILD_WRAPPER_CLASS is None: 150 raise NotImplementedError 151 if type(self.CHILD_WRAPPER_CLASS) is type(''): 152 # resolve class 153 if hasattr(omero.gateway, self.CHILD_WRAPPER_CLASS): 154 self.__class__.CHILD_WRAPPER_CLASS = self.CHILD_WRAPPER_CLASS = getattr(omero.gateway, self.CHILD_WRAPPER_CLASS) 155 else: #pragma: no cover 156 raise NotImplementedError 157 return self.CHILD_WRAPPER_CLASS
158
159 - def _getParentWrapper (self):
160 if self.PARENT_WRAPPER_CLASS is None: 161 raise NotImplementedError 162 if type(self.PARENT_WRAPPER_CLASS) is type(''): 163 # resolve class 164 g = globals() 165 if not g.has_key(self.PARENT_WRAPPER_CLASS): #pragma: no cover 166 raise NotImplementedError 167 self.__class__.PARENT_WRAPPER_CLASS = self.PARENT_WRAPPER_CLASS = g[self.PARENT_WRAPPER_CLASS] 168 return self.PARENT_WRAPPER_CLASS
169
170 - def __loadedHotSwap__ (self):
171 self._obj = self._conn.getContainerService().loadContainerHierarchy(self.OMERO_CLASS, (self._oid,), None)[0]
172 173 180 191
192 - def findChildByName (self, name, description=None):
193 for c in self.listChildren(): 194 if c.getName() == name: 195 if description is None or omero_type(description) == omero_type(c.getDescription()): 196 return c 197 return None
198
199 - def getDetails (self):
200 if self._obj.loaded: 201 return omero.gateway.DetailsWrapper (self._conn, self._obj.getDetails()) 202 return None
203
204 - def getDate(self):
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
214 - def save (self):
215 self._obj = self._conn.getUpdateService().saveAndReturnObject(self._obj)
216
217 - def saveAs (self, details):
218 """ Save this object, keeping the object owner the same as the one on provided details """ 219 if self._conn.isAdmin(): 220 d = self.getDetails() 221 if d.getOwner() and \ 222 d.getOwner().omeName == details.getOwner().omeName and \ 223 d.getGroup().name == details.getGroup().name: 224 return self.save() 225 else: 226 newConn = self._conn.suConn(details.getOwner().omeName, details.getGroup().name) 227 #p = omero.sys.Principal() 228 #p.name = details.getOwner().omeName 229 #p.group = details.getGroup().name 230 #p.eventType = "User" 231 #newConnId = self._conn.getSessionService().createSessionWithTimeout(p, 60000) 232 #newConn = self._conn.clone() 233 #newConn.connect(sUuid=newConnId.getUuid().val) 234 clone = self.__class__(newConn, self._obj) 235 clone.save() 236 self._obj = clone._obj 237 return 238 else: 239 return self.save()
240
241 - def canWrite (self):
242 return self._conn.canWrite(self._obj)
243
244 - def canOwnerWrite (self):
245 return self._obj.details.permissions.isUserWrite()
246
247 - def canDelete(self):
248 return self.isOwned() or self.isLeaded()
249
250 - def isOwned(self):
251 return (self._obj.details.owner.id.val == self._conn.getEventContext().userId)
252
253 - def isLeaded(self):
254 if self._obj.details.group.id.val in self._conn.getEventContext().leaderOfGroups: 255 return True 256 return False
257
258 - def isEditable(self):
259 if self.isOwned(): 260 return True 261 elif not self.isPrivate() and not self.isReadOnly(): 262 return True 263 return False
264
265 - def isPublic(self):
266 return self._obj.details.permissions.isWorldRead()
267
268 - def isShared(self):
269 if not self.isPublic(): 270 return self._obj.details.permissions.isGroupRead() 271 return False
272
273 - def isPrivate(self):
274 if not self.isPublic() and not self.isShared(): 275 return self._obj.details.permissions.isUserRead() 276 return False
277
278 - def isReadOnly(self):
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 #@timeit 288 #def getUID (self): 289 # p = self.listParents() 290 # return p and '%s:%s' % (p.getUID(), str(self.id)) or str(self.id) 291 292 #def getChild (self, oid): 293 # q = self._conn.getQueryService() 294 # ds = q.find(self.CHILD_WRAPPER_CLASS.OMERO_CLASS, long(oid)) 295 # if ds is not None: 296 # ds = self.CHILD_WRAPPER_CLASS(self._conn, ds) 297 # return ds 298
299 - def countChildren (self):
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 #self._cached_countChildren = len(self._conn.getQueryService().findAllByQuery("from %s as c where c.parent.id=%i" % (self.LINK_CLASS, self._oid), None)) 309 self._cached_countChildren = self._conn.getContainerService().getCollectionCount(self.OMERO_CLASS, klass, [self._oid], None)[self._oid] 310 return self._cached_countChildren
311
312 - def countChildren_cached (self):
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
325 - def listChildren (self, ns=None, val=None, params=None):
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 # if getattr(self, 'is%sLinksLoaded' % klass)(): 335 # childns = getattr(self, 'copy%sLinks' % klass)() 336 # childnodes = [ x.child for x in childns] 337 # logger.debug('listChildren for %s %d: already loaded' % (self.OMERO_CLASS, self.getId())) 338 # else: 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 #query += """ join c.child.annotationLinks ial 348 # join ial.child as a """ 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 #def listChildren_cached (self): 365 # """ This version caches all child nodes for all parents, so next parent does not need to search again. 366 # Good for full depth traversal, but a waste of time otherwise """ 367 # if self.CHILD_WRAPPER_CLASS is None: #pragma: no cover 368 # raise NotImplementedError 369 # if not self._cache.has_key(self.LINK_CLASS): 370 # pdl = {} 371 # for link in self._conn.getQueryService().findAll(self.LINK_CLASS, None): 372 # pid = link.parent.id.val 373 # if pdl.has_key(pid): 374 # pdl[pid].append(link.child) 375 # else: 376 # pdl[pid] = [link.child] 377 # self._cache[self.LINK_CLASS] = pdl 378 # for child in self._cache[self.LINK_CLASS].get(self._oid, ()): 379 # yield self.CHILD_WRAPPER_CLASS(self._conn, child, self._cache) 380
381 - def listParents (self, single=True, withlinks=False):
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() # TODO: What can I use this for? 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
403 - def getAncestry (self):
404 rv = [] 405 p = self.listParents() 406 while p: 407 rv.append(p) 408 p = p.listParents() 409 return rv
410 411 419 420 427 428
429 - def removeAnnotations (self, ns):
430 for al in self._getAnnotationLinks(ns=ns): 431 a = al.child 432 update = self._conn.getUpdateService() 433 update.deleteObject(al) 434 update.deleteObject(a) 435 self._obj.unloadAnnotationLinks()
436
437 - def getAnnotation (self, ns=None):
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
448 - def listAnnotations (self, ns=None):
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
459 - def _linkAnnotation (self, ann):
460 if not ann.getId(): 461 # Not yet in db, save it 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 #else: 467 # ann.save() 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
480 - def linkAnnotation (self, ann, sameOwner=True):
481 if sameOwner: 482 d = self.getDetails() 483 ad = ann.getDetails() 484 if self._conn.isAdmin() and self._conn._userid != d.getOwner().id: 485 # Keep the annotation owner the same as the linked of object's 486 if ad.getOwner() and d.getOwner().omeName == ad.getOwner().omeName and d.getGroup().name == ad.getGroup().name: 487 newConn = ann._conn 488 else: 489 #p = omero.sys.Principal() 490 #p.name = d.getOwner().omeName 491 group = None 492 if d.getGroup(): 493 group = d.getGroup().name 494 newConn = self._conn.suConn(d.getOwner().omeName, group) 495 #p.eventType = "User" 496 #newConnId = self._conn.getSessionService().createSessionWithTimeout(p, 60000) 497 #newConn = self._conn.clone() 498 #newConn.connect(sUuid=newConnId.getUuid().val) 499 clone = self.__class__(newConn, self._obj) 500 ann = clone._linkAnnotation(ann) 501 elif d.getGroup(): 502 # Try to match group 503 self._conn.setGroupForSession(d.getGroup().getId()) 504 ann = self._linkAnnotation(ann) 505 self._conn.revertGroupForSession() 506 else: 507 ann = self._linkAnnotation(ann) 508 else: 509 ann = self._linkAnnotation(ann) 510 self.unloadAnnotationLinks() 511 return ann
512 513
514 - def simpleMarshal (self, xtra=None, parents=False):
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 # 'key' -> key = _obj[key] 522 # '#key' -> key = _obj[key].value.val 523 # 'key;title' -> title = _obj[key] 524 # 'key|wrapper' -> key = omero.gateway.wrapper(_obj[key]).simpleMarshal 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: # TODO check if this can be moved to a more specific place 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 #def __str__ (self): 562 # if hasattr(self._obj, 'value'): 563 # return str(self.value) 564 # return str(self._obj) 565
566 - def __getattr__ (self, attr):
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 # Broken code here 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 # some methods are accessors in _obj and return and omero:: type. The obvious ones we wrap to return a python type 594
595 - def getId (self):
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
606 - def getName (self):
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
620 - def getDescription (self):
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
630 - def getOwner (self):
631 """ 632 Gets user who is the owner of this object. 633 634 @return: _ExperimenterWrapper 635 """ 636 637 return self.getDetails().getOwner()
638
639 - def getOwnerFullName (self):
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
660 - def getOwnerOmeName (self):
661 """ 662 Gets omeName of the owner of this object. 663 664 @return: String 665 """ 666 return self.getDetails().getOwner().omeName
667
668 - def creationEventDate(self):
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
684 - def updateEventDate(self):
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 # setters are also provided 702
703 - def setName (self, value):
704 self._obj.setName(omero_type(value))
705
706 - def setDescription (self, value):
707 self._obj.setDescription(omero_type(value))
708
709 ## BASIC ## 710 711 -class NoProxies (object):
712 - def __getitem__ (self, k):
713 raise Ice.ConnectionLostException
714
715 -class _BlitzGateway (object):
716 """ 717 ICE_CONFIG - Defines the path to the Ice configuration 718 """ 719 720 ICE_CONFIG = None#os.path.join(p,'etc/ice.config') 721 # def __init__ (self, username, passwd, server, port, client_obj=None, group=None, clone=False): 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 #logger.debug('super: %s %s %s' % (try_super, str(group), self.c.ic.getProperties().getProperty('omero.gateway.admin_group'))) 758 if try_super: 759 self.group = 'system' #self.c.ic.getProperties().getProperty('omero.gateway.admin_group') 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 # The properties we are setting through the interface 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
776 - def getProperty(self, k):
777 return self.c.getProperty(k)
778
779 - def clone (self):
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 #self.server, self.port, clone=True) 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):
803 """ If current user isAdmin, return new connection owned by 'username' """ 804 if self.isAdmin(): 805 if group is None: 806 e = self.lookupExperimenter(username) 807 if e is None: 808 return 809 group = e._obj._groupExperimenterMapSeq[0].parent.name.val 810 p = omero.sys.Principal() 811 p.name = username 812 p.group = group 813 p.eventType = "User" 814 newConnId = self.getSessionService().createSessionWithTimeout(p, ttl) 815 newConn = self.clone() 816 newConn.connect(sUuid=newConnId.getUuid().val) 817 return newConn
818
819 - def keepAlive (self):
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: #pragma: no cover 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: #pragma: no cover 833 # The connection is there, but it has been reset, because the proxy no longer exists... 834 logger.debug(traceback.format_exc()) 835 logger.debug("... reset, not reconnecting") 836 return False 837 except Ice.ConnectionLostException: #pragma: no cover 838 # The connection was lost. This shouldn't happen, as we keep pinging it, but does so... 839 logger.debug(traceback.format_exc()) 840 logger.debug("... lost, reconnecting") 841 #return self.connect() 842 return False 843 except Ice.ConnectionRefusedException: #pragma: no cover 844 # The connection was refused. We lost contact with glacier2router... 845 logger.debug(traceback.format_exc()) 846 logger.debug("... refused, not reconnecting") 847 return False 848 except omero.SessionTimeoutException: #pragma: no cover 849 # The connection is there, but it has been reset, because the proxy no longer exists... 850 logger.debug(traceback.format_exc()) 851 logger.debug("... reset, not reconnecting") 852 return False 853 except omero.RemovedSessionException: #pragma: no cover 854 # Session died on us 855 logger.debug(traceback.format_exc()) 856 logger.debug("... session has left the building, not reconnecting") 857 return False 858 except Ice.UnknownException, x: #pragma: no cover 859 # Probably a wrapped RemovedSession 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 # Something else happened 866 logger.debug(traceback.format_exc()) 867 logger.debug("... error not reconnecting") 868 return False
869
870 - def seppuku (self, softclose=False): #pragma: no cover
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
901 - def __del__ (self):
902 logger.debug("##GARBAGE COLLECTOR KICK IN")
903
904 - def _createProxies (self):
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 # "guest" user has no access that method. 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: #pragma: no cover 951 if self._was_join: 952 self._session_cb.join(self) 953 else: 954 self._session_cb.create(self)
955
956 - def setSecure (self, secure=True):
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
964 - def isSecure (self):
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
968 - def _createSession (self, skipSUuid=False):
969 """ 970 Creates a new session for the principal given in the constructor. 971 """ 972 s = self.c.createSession(self._ic_props[omero.constants.USERNAME], 973 self._ic_props[omero.constants.PASSWORD]) 974 self._sessionUuid = self.c.sf.ice_getIdentity().name 975 ss = self.c.sf.getSessionService() 976 self._session = ss.getSession(self._sessionUuid) 977 self._lastGroupId = None 978 s.detachOnDestroy() 979 self._was_join = False 980 if self.group is not None: 981 # try something that fails if the user don't have permissions on the group 982 self.c.sf.getAdminService().getEventContext() 983 self.setSecure(self.secure)
984
985 - def _closeSession (self):
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 #r = 1 996 #while r: 997 # r = self.c.sf.getSessionService().closeSession(s) 998 # it is not neccessary to go through every workers. 999 # if cannot get session service for killSession will use closeSession 1000 self.c.killSession() 1001 except Ice.ObjectNotExistException: 1002 pass 1003 except omero.RemovedSessionException: 1004 pass 1005 except ValueError: 1006 raise 1007 except: #pragma: no cover 1008 logger.warn(traceback.format_exc()) 1009 else: 1010 try: 1011 self.c.killSession() 1012 except Glacier2.SessionNotExistException: #pragma: no cover 1013 pass 1014 except: 1015 logger.warn(traceback.format_exc())
1016
1017 - def _resetOmeroClient (self):
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))#, pmap=['--Ice.Config='+','.join(self.ice_config)]) 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
1033 - def connect (self, sUuid=None):
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: #pragma: no cover 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: #pragma: no cover 1062 raise 1063 except Exception, x: #pragma: no cover 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: #pragma: no cover 1070 logger.debug("Uncaptured sUuid failure!") 1071 if self._connected: 1072 self._connected = False 1073 try: 1074 #args = self.c._ic_args 1075 #logger.debug(str(args)) 1076 self._closeSession() 1077 self._resetOmeroClient() 1078 #self.c = omero.client(*args) 1079 except Glacier2.SessionNotExistException: #pragma: no cover 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 # User don't have access to group 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: #pragma: no cover 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 #time.sleep(10) 1102 try: 1103 self._createSession() 1104 except omero.SecurityViolation: 1105 if self.group is not None: 1106 # User don't have access to group 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: #pragma: no cover 1114 raise 1115 except: 1116 logger.info("BlitzGateway.connect().createSession(): " + traceback.format_exc()) 1117 logger.debug(str(self._ic_props)) 1118 #time.sleep(10) 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: #pragma: no cover 1126 logger.debug('This one is a SyscallException') 1127 raise 1128 except Ice.LocalException, x: #pragma: no cover 1129 logger.debug("connect(): " + traceback.format_exc()) 1130 self._last_error = x 1131 return False 1132 except Exception, x: #pragma: no cover 1133 logger.debug("connect(): " + traceback.format_exc()) 1134 self._last_error = x 1135 return False 1136 logger.debug(".. connected!") 1137 return True
1138
1139 - def getLastError (self): #pragma: no cover
1140 """ 1141 Returns error if thrown by _BlitzGateway.connect connect. 1142 1143 @return: String 1144 """ 1145 1146 return self._last_error 1147
1148 - def isConnected (self):
1149 """ 1150 Returns last status of connection. 1151 1152 @return: Boolean 1153 """ 1154 1155 return self._connected
1156 1157 ###################### 1158 ## Connection Stuff ## 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
1175 - def getUser (self):
1176 """ 1177 Returns current omero_model_ExperimenterI. 1178 1179 @return: omero.model.ExperimenterI 1180 """ 1181 1182 return self._user
1183
1184 - def getGroupFromContext(self):
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
1195 - def isAdmin (self):
1196 """ 1197 Checks if a user has administration privileges. 1198 1199 @return: Boolean 1200 """ 1201 1202 return self.getEventContext().isAdmin
1203
1204 - def canBeAdmin (self):
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
1212 - def isOwner (self, gid=None):
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
1230 - def canWrite (self, obj):
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
1240 - def getSession (self):
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 # def setDefaultPermissionsForSession (self, permissions): 1247 # self.getSession() 1248 # self._session.setDefaultPermissions(rstring(permissions)) 1249 # self._session.setTimeToIdle(None) 1250 # self.getSessionService().updateSession(self._session) 1251
1252 - def setGroupNameForSession (self, group):
1253 a = self.getAdminService() 1254 g = a.lookupGroup(group) 1255 return self.setGroupForSession(g.getId().val)
1256
1257 - def setGroupForSession (self, groupid):
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 # Beta4.2 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 # def setGroupForSession (self, group): 1275 # self.getSession() 1276 # if self._session.getDetails().getGroup().getId().val == group.getId(): 1277 # # Already correct 1278 # return 1279 # a = self.getAdminService() 1280 # if not group.name in [x.name.val for x in a.containedGroups(self._userid)]: 1281 # # User not in this group 1282 # return 1283 # self._lastGroup = self._session.getDetails().getGroup() 1284 # self._session.getDetails().setGroup(group._obj) 1285 # self._session.setTimeToIdle(None) 1286 # self.getSessionService().updateSession(self._session) 1287 #
1288 - def revertGroupForSession (self):
1289 if self._lastGroupId is not None: 1290 self.setGroupForSession(self._lastGroupId) 1291 self._lastGroupId = None
1292 1293 ############## 1294 ## Services ## 1295
1296 - def getAdminService (self):
1297 """ 1298 Gets reference to the admin service from ProxyObjectWrapper. 1299 1300 @return: omero.gateway.ProxyObjectWrapper 1301 """ 1302 1303 return self._proxies['admin']
1304
1305 - def getQueryService (self):
1306 """ 1307 Gets reference to the query service from ProxyObjectWrapper. 1308 1309 @return: omero.gateway.ProxyObjectWrapper 1310 """ 1311 return self._proxies['query']
1312
1313 - def getContainerService (self):
1314 """ 1315 Gets reference to the container service from ProxyObjectWrapper. 1316 1317 @return: omero.gateway.ProxyObjectWrapper 1318 """ 1319 1320 return self._proxies['container']
1321
1322 - def getPixelsService (self):
1323 """ 1324 Gets reference to the pixels service from ProxyObjectWrapper. 1325 1326 @return: omero.gateway.ProxyObjectWrapper 1327 """ 1328 1329 return self._proxies['pixel']
1330
1331 - def getMetadataService (self):
1332 """ 1333 Gets reference to the metadata service from ProxyObjectWrapper. 1334 1335 @return: omero.gateway.ProxyObjectWrapper 1336 """ 1337 1338 return self._proxies['metadata']
1339
1340 - def getRoiService (self):
1341 """ 1342 Gets ROI service. 1343 1344 @return: omero.gateway.ProxyObjectWrapper 1345 """ 1346 1347 return self._proxies['roi']
1348
1349 - def getScriptService (self):
1350 """ 1351 Gets script service. 1352 1353 @return: omero.gateway.ProxyObjectWrapper 1354 """ 1355 1356 return self._proxies['script']
1357
1358 - def createRawFileStore (self):
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
1369 - def getRepositoryInfoService (self):
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
1378 - def getShareService(self):
1379 """ 1380 Gets reference to the share service from ProxyObjectWrapper. 1381 1382 @return: omero.gateway.ProxyObjectWrapper 1383 """ 1384 1385 return self._proxies['share']
1386
1387 - def getTimelineService (self):
1388 """ 1389 Gets reference to the timeline service from ProxyObjectWrapper. 1390 1391 @return: omero.gateway.ProxyObjectWrapper 1392 """ 1393 1394 return self._proxies['timeline']
1395
1396 - def getTypesService(self):
1397 """ 1398 Gets reference to the types service from ProxyObjectWrapper. 1399 1400 @return: omero.gateway.ProxyObjectWrapper 1401 """ 1402 1403 return self._proxies['types']
1404
1405 - def getConfigService (self):
1406 """ 1407 Gets reference to the config service from ProxyObjectWrapper. 1408 1409 @return: omero.gateway.ProxyObjectWrapper 1410 """ 1411 1412 return self._proxies['config']
1413
1414 - def createRenderingEngine (self):
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
1429 - def getRenderingSettingsService (self):
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
1438 - def createRawPixelsStore (self):
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
1449 - def createThumbnailStore (self):
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
1460 - def createSearchService (self):
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
1470 - def getUpdateService (self):
1471 """ 1472 Gets reference to the update service from ProxyObjectWrapper. 1473 1474 @return: omero.gateway.ProxyObjectWrapper 1475 """ 1476 return self._proxies['update']
1477
1478 - def getDeleteService (self):
1479 """ 1480 Gets reference to the delete service from ProxyObjectWrapper. 1481 1482 @return: omero.gateway.ProxyObjectWrapper 1483 """ 1484 return self._proxies['delete']
1485
1486 - def getSessionService (self):
1487 """ 1488 Gets reference to the session service from ProxyObjectWrapper. 1489 1490 @return: omero.gateway.ProxyObjectWrapper 1491 """ 1492 return self._proxies['session']
1493
1494 - def createExporter (self):
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 # Top level object fetchers # 1505
1506 - def listProjects (self, only_owned=False):
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 # def listCategoryGroups (self): 1526 # q = self.getQueryService() 1527 # cache = {} 1528 # for e in q.findAll("CategoryGroup", None): 1529 # yield CategoryGroupWrapper(self, e, cache) 1530 1531 1532 ################################################# 1533 ## IAdmin 1534 1535 # GROUPS 1536
1537 - def getGroup(self, gid):
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
1544 - def lookupGroup(self, name):
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
1551 - def getDefaultGroup(self, eid):
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
1558 - def getOtherGroups(self, eid):
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
1566 - def getGroupsLeaderOf(self):
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
1577 - def getGroupsMemberOf(self):
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 # EXPERIMENTERS 1592
1593 - def lookupExperimenters(self):
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
1601 - def getExperimenter(self, eid):
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
1616 - def lookupExperimenter(self, name):
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
1631 - def containedExperimenters(self, gid):
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
1639 - def getColleagues(self):
1640 """ Look up users who are a member of the current user active group.""" 1641 1642 default = self.getGroup(self.getEventContext().groupId) 1643 if not default.isPrivate() or default.isLeader(): 1644 for d in default.copyGroupExperimenterMap(): 1645 if d.child.id.val != self.getEventContext().userId: 1646 yield ExperimenterWrapper(self, d.child)
1647
1648 - def getStaffs(self):
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
1662 - def getColleaguesAndStaffs(self):
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
1680 - def lookupGroups(self):
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
1688 - def lookupOwnedGroups(self):
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 # Repository info
1697 - def getUsedSpace(self):
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
1704 - def getFreeSpace(self):
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
1711 - def getUsage(self):
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
1751 - def bytesPerPixel(self, pixel_type):
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 ## IShare 1767
1768 - def getOwnShares(self):
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
1775 - def getMemberShares(self):
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
1782 - def getMemberCount(self, share_ids):
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
1789 - def getCommentCount(self, share_ids):
1790 """ Returns a map from share id to comment count. """ 1791 1792 sh = self.getShareService() 1793 return sh.getCommentCount(share_ids)
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
1802 - def getComments(self, share_id):
1803 """ Looks up all comments which belong to the share.""" 1804 1805 sh = self.getShareService() 1806 for e in sh.getComments(long(share_id)): 1807 yield ShareCommentWrapper(self, e)
1808
1809 - def getAllMembers(self, share_id):
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
1816 - def getAllGuests(self, share_id):
1817 """ Get the email addresses for all share guests.""" 1818 1819 sh = self.getShareService() 1820 return sh.getAllGuests(long(share_id))
1821
1822 - def getAllUsers(self, share_id):
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 # ITimeline # 1830
1831 - def timelineListImages (self, tfrom=None, tto=None, limit=10, only_owned=True):
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 # Specific Object Getters # 1867
1868 - def getProject (self, oid):
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
1882 - def findProject (self, name):
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
1899 - def getDataset (self, oid):
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
1913 - def getImage (self, oid):
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
1927 - def getShare (self, oid):
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
1937 - def getScreen (self, oid):
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
1949 - def getPlate (self, oid):
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
1963 - def getSpecifiedImages(self, oids):
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
1972 - def getSpecifiedDatasets(self, oids):
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
1981 - def getSpecifiedProjects(self, oids):
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
1990 - def getSpecifiedPlates(self, oids):
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 # Annotations # 2001
2002 - def getFileAnnotation (self, oid):
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
2011 - def getCommentAnnotation (self, oid):
2012 query_serv = self.getQueryService() 2013 p = omero.sys.Parameters() 2014 p.map = {} 2015 p.map["oid"] = rlong(long(oid)) 2016 sql = "select ca from CommentAnnotation ca where ca.id = :oid" 2017 ta = query_serv.findByQuery(sql, p) 2018 return AnnotationWrapper(self, ta)
2019
2020 - def getTagAnnotation (self, oid):
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
2029 - def lookupTagAnnotation (self, name):
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 # Annotation based iterators # 2045
2046 - def listImages (self, ns, params=None):
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 # Enumerations # 2071
2072 - def getEnumerationEntries(self, klass):
2073 types = self.getTypesService() 2074 for e in types.allEnumerations(str(klass)): 2075 yield EnumerationWrapper(self, e)
2076
2077 - def getEnumeration(self, klass, string):
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
2085 - def getEnumerationById(self, klass, eid):
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
2093 - def getOriginalEnumerations(self):
2094 types = self.getTypesService() 2095 rv = dict() 2096 for e in types.getOriginalEnumerations(): 2097 if rv.get(e.__class__.__name__) is None: 2098 rv[e.__class__.__name__] = list() 2099 rv[e.__class__.__name__].append(EnumerationWrapper(self, e)) 2100 return rv
2101
2102 - def getEnumerations(self):
2103 types = self.getTypesService() 2104 return types.getEnumerationTypes()
2105
2106 - def getEnumerationsWithEntries(self):
2107 types = self.getTypesService() 2108 rv = dict() 2109 for key, value in types.getEnumerationsWithEntries().items(): 2110 r = list() 2111 for e in value: 2112 r.append(EnumerationWrapper(self, e)) 2113 rv[key+"I"] = r 2114 return rv
2115
2116 - def deleteEnumeration(self, obj):
2117 types = self.getTypesService() 2118 types.deleteEnumeration(obj)
2119
2120 - def createEnumeration(self, obj):
2121 types = self.getTypesService() 2122 types.createEnumeration(obj)
2123
2124 - def resetEnumerations(self, klass):
2125 types = self.getTypesService() 2126 types.resetEnumerations(klass)
2127
2128 - def updateEnumerations(self, new_entries):
2129 types = self.getTypesService() 2130 types.updateEnumerations(new_entries)
2131 2132 ################### 2133 # Delete # 2134
2135 - def deleteObject(self, obj):
2136 u = self.getUpdateService() 2137 u.deleteObject(obj)
2138
2139 - def deleteAnnotation(self, oid, child=None, anns=None):
2140 op = dict() 2141 dc = omero.api.delete.DeleteCommand('/Annotation', long(oid), op) 2142 handle = self.getDeleteService().queueDelete([dc]) 2143 return handle
2144
2145 - def deleteImage(self, oid, anns=None):
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
2155 - def deleteImages(self, ids, anns=None):
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
2167 - def deletePlate(self, oid, anns=None):
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
2177 - def deleteDataset(self, obj, child=None, anns=None):
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
2189 - def deleteProject(self, obj, child=None, anns=None):
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
2202 - def deleteScreen(self, obj, child=None, anns=None):
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 # Searching stuff # 2216 2217 2218 #def searchImages (self, text): 2219 # """ 2220 # Fulltext search for images 2221 # """ 2222 # return self.simpleSearch(text,(ImageWrapper,)) 2223
2224 - def searchImages (self, text=None, created=None):
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
2237 - def searchDatasets (self, text=None, created=None):
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
2252 - def searchProjects (self, text=None, created=None):
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
2265 - def searchScreens (self, text=None, created=None):
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
2278 - def searchPlates (self, text=None, created=None):
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
2291 - def simpleSearch (self, text, types=None):
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
2319 -def safeCallWrap (self, attr, f): #pragma: no cover
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 # Failed 2342 logger.debug( "Ice.Exception (1) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs))) 2343 logger.debug(traceback.format_exc()) 2344 # Recreate the proxy object 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 # Still Failed 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 # Recreate connection 2357 self._connect() 2358 logger.debug('last try for %s' % attr) 2359 # Last try, don't catch exception 2360 func = getattr(self._obj, attr) 2361 return func(*args, **kwargs) 2362 except: 2363 raise 2364 2365 def wrapped (*args, **kwargs): #pragma: no cover 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 #time.sleep(10) 2395 return inner(*args, **kwargs) 2396 return wrapped 2397 2398 2399 BlitzGateway = _BlitzGateway
2400 2401 2402 -def splitHTMLColor (color):
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
2426 2427 -class ProxyObjectWrapper (object):
2428 - def __init__ (self, conn, func_str):
2429 self._obj = None 2430 self._func_str = func_str 2431 self._resyncConn(conn) 2432 self._tainted = False
2433
2434 - def clone (self):
2435 return ProxyObjectWrapper(self._conn, self._func_str)
2436
2437 - def _connect (self): #pragma: no cover
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
2456 - def taint (self):
2457 self._tainted = True
2458
2459 - def untaint (self):
2460 self._tainted = False
2461
2462 - def close (self):
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
2471 - def _resyncConn (self, conn):
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
2488 - def _getObj (self):
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
2499 - def _ping (self): #pragma: no cover
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 # The connection is there, but it has been reset, because the proxy no longer exists... 2512 logger.debug("... reset, reconnecting") 2513 self._connect() 2514 return False 2515 except Ice.ConnectionLostException: 2516 # The connection was lost. This shouldn't happen, as we keep pinging it, but does so... 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 # The connection was refused. We lost contact with glacier2router... 2524 logger.debug(traceback.format_stack()) 2525 logger.debug("... refused, reconnecting") 2526 self._connect() 2527 return False 2528 except omero.RemovedSessionException: 2529 # Session died on us 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 # Probably a wrapped RemovedSession 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
2542 - def __getattr__ (self, attr):
2543 """ 2544 2545 @param attr: Connection 2546 @return: rv 2547 """ 2548 # safe call wrapper 2549 obj = self._obj or self._getObj() 2550 rv = getattr(obj, attr) 2551 if callable(rv): 2552 rv = safeCallWrap(self, attr, rv) 2553 #self._conn.updateTimeout() 2554 return rv
2555
2556 2557 -class AnnotationWrapper (BlitzObjectWrapper):
2558 """ 2559 omero_model_AnnotationI class wrapper extends BlitzObjectWrapper. 2560 """ 2561 registry = {} 2562 OMERO_TYPE = None 2563
2564 - def __init__ (self, *args, **kwargs):
2565 super(AnnotationWrapper, self).__init__(*args, **kwargs) 2566 self.link = kwargs.has_key('link') and kwargs['link'] or None 2567 if self._obj is None and self.OMERO_TYPE is not None: 2568 self._obj = self.OMERO_TYPE()
2569
2570 - def __eq__ (self, a):
2571 return type(a) == type(self) and self._obj.id == a._obj.id and self.getValue() == a.getValue() and self.getNs() == a.getNs()
2572 2573 @classmethod
2574 - def _register (klass, regklass):
2575 klass.registry[regklass.OMERO_TYPE] = regklass
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: #pragma: no cover 2585 return None
2586 2587 @classmethod 2594
2595 - def getNs (self):
2596 return self._obj.ns is not None and self._obj.ns.val or None
2597
2598 - def setNs (self, val):
2599 self._obj.ns = omero_type(val)
2600
2601 - def getValue (self): #pragma: no cover
2602 raise NotImplementedError
2603
2604 - def setValue (self, val): #pragma: no cover
2605 raise NotImplementedError 2606 2607 from omero_model_FileAnnotationI import FileAnnotationI
2608 2609 -class FileAnnotationWrapper (AnnotationWrapper):
2610 """ 2611 omero_model_FileAnnotatio class wrapper extends AnnotationWrapper. 2612 """ 2613 2614 OMERO_TYPE = FileAnnotationI 2615
2616 - def __loadedHotSwap__ (self):
2617 if not self._obj.file.loaded: 2618 self._obj._file = self._conn.getQueryService().find('OriginalFile', self._obj.file.id.val)
2619
2620 - def getValue (self):
2621 pass
2622
2623 - def setValue (self, val):
2624 pass
2625
2626 - def isOriginalMetadata(self):
2627 self.__loadedHotSwap__() 2628 try: 2629 if self._obj.ns is not None and self._obj.ns.val == omero.constants.namespaces.NSCOMPANIONFILE and self._obj.file.name.val.startswith("original_metadata"): 2630 return True 2631 except: 2632 logger.info(traceback.format_exc()) 2633 return False
2634
2635 - def getFileSize(self):
2636 return self._obj.file.size.val
2637
2638 - def getFileName(self):
2639 self.__loadedHotSwap__() 2640 return self._obj.file.name.val
2641
2642 - def getFileInChunks(self):
2643 self.__loadedHotSwap__() 2644 store = self._conn.createRawFileStore() 2645 store.setFileId(self._obj.file.id.val) 2646 size = self.getFileSize() 2647 buf = 2621440 2648 if size <= buf: 2649 yield store.read(0,long(size)) 2650 else: 2651 for pos in range(0,long(size),buf): 2652 data = None 2653 if size-pos < buf: 2654 data = store.read(pos, size-pos) 2655 else: 2656 data = store.read(pos, buf) 2657 yield data 2658 store.close()
2659 2660 # def shortTag(self): 2661 # if isinstance(self._obj, TagAnnotationI): 2662 # try: 2663 # name = self._obj.textValue.val 2664 # l = len(name) 2665 # if l < 25: 2666 # return name 2667 # return name[:10] + "..." + name[l - 10:] 2668 # except: 2669 # logger.info(traceback.format_exc()) 2670 # return self._obj.textValue.val 2671 2672 AnnotationWrapper._register(FileAnnotationWrapper) 2673 2674 from omero_model_TimestampAnnotationI import TimestampAnnotationI
2675 2676 -class TimestampAnnotationWrapper (AnnotationWrapper):
2677 """ 2678 omero_model_TimestampAnnotatio class wrapper extends AnnotationWrapper. 2679 """ 2680 2681 OMERO_TYPE = TimestampAnnotationI 2682
2683 - def getValue (self):
2684 return datetime.fromtimestamp(self._obj.timeValue.val / 1000.0)
2685
2686 - def setValue (self, val):
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
2697 2698 -class BooleanAnnotationWrapper (AnnotationWrapper):
2699 """ 2700 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper. 2701 """ 2702 2703 OMERO_TYPE = BooleanAnnotationI 2704
2705 - def getValue (self):
2706 return self._obj.boolValue.val
2707
2708 - def setValue (self, val):
2709 self._obj.boolValue = rbool(not not val)
2710 2711 AnnotationWrapper._register(BooleanAnnotationWrapper) 2712 2713 from omero_model_TagAnnotationI import TagAnnotationI
2714 2715 -class TagAnnotationWrapper (AnnotationWrapper):
2716 """ 2717 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper. 2718 """ 2719 2720 OMERO_TYPE = TagAnnotationI 2721
2722 - def getValue (self):
2723 return self._obj.textValue.val
2724
2725 - def setValue (self, val):
2726 self._obj.textValue = rbool(not not val)
2727 2728 AnnotationWrapper._register(TagAnnotationWrapper) 2729 2730 from omero_model_CommentAnnotationI import CommentAnnotationI
2731 2732 -class CommentAnnotationWrapper (AnnotationWrapper):
2733 """ 2734 omero_model_CommentAnnotationI class wrapper extends AnnotationWrapper. 2735 """ 2736 2737 OMERO_TYPE = CommentAnnotationI 2738
2739 - def getValue (self):
2740 return self._obj.textValue.val
2741
2742 - def setValue (self, val):
2743 self._obj.textValue = omero_type(val)
2744 2745 AnnotationWrapper._register(CommentAnnotationWrapper) 2746 2747 from omero_model_LongAnnotationI import LongAnnotationI
2748 2749 -class LongAnnotationWrapper (AnnotationWrapper):
2750 """ 2751 omero_model_LongAnnotationI class wrapper extends AnnotationWrapper. 2752 """ 2753 OMERO_TYPE = LongAnnotationI 2754
2755 - def getValue (self):
2756 return self._obj.longValue.val
2757
2758 - def setValue (self, val):
2759 self._obj.longValue = rlong(val)
2760 2761 AnnotationWrapper._register(LongAnnotationWrapper) 2762 2763 from omero_model_DoubleAnnotationI import DoubleAnnotationI
2764 2765 -class DoubleAnnotationWrapper (AnnotationWrapper):
2766 """ 2767 omero_model_DoubleAnnotationI class wrapper extends AnnotationWrapper. 2768 """ 2769 OMERO_TYPE = DoubleAnnotationI 2770
2771 - def getValue (self):
2772 return self._obj.doubleValue.val
2773
2774 - def setValue (self, val):
2775 self._obj.doubleValue = rdouble(val)
2776 2777 AnnotationWrapper._register(DoubleAnnotationWrapper) 2778 2779 from omero_model_TermAnnotationI import TermAnnotationI
2780 2781 -class TermAnnotationWrapper (AnnotationWrapper):
2782 """ 2783 omero_model_TermAnnotationI class wrapper extends AnnotationWrapper. 2784 """ 2785 OMERO_TYPE = TermAnnotationI 2786
2787 - def getValue (self):
2788 return self._obj.termValue.val
2789
2790 - def setValue (self, val):
2791 self._obj.termValue = rstring(val)
2792 2793 AnnotationWrapper._register(TermAnnotationWrapper) 2794 2795 from omero_model_XmlAnnotationI import XmlAnnotationI
2796 2797 -class XmlAnnotationWrapper (CommentAnnotationWrapper):
2798 """ 2799 omero_model_XmlAnnotationI class wrapper extends CommentAnnotationWrapper. 2800 """ 2801 OMERO_TYPE = XmlAnnotationI
2802 2803 AnnotationWrapper._register(XmlAnnotationWrapper)
2804 2805 -class _EnumerationWrapper (BlitzObjectWrapper):
2806
2807 - def getType(self):
2808 return self._obj.__class__
2809 2810 EnumerationWrapper = _EnumerationWrapper
2811 2812 -class _ExperimenterWrapper (BlitzObjectWrapper):
2813 """ 2814 omero_model_ExperimenterI class wrapper extends BlitzObjectWrapper. 2815 """ 2816
2817 - def __bstrap__ (self):
2818 self.OMERO_CLASS = 'Experimenter' 2819 self.LINK_CLASS = "copyGroupExperimenterMap" 2820 self.CHILD_WRAPPER_CLASS = None 2821 self.PARENT_WRAPPER_CLASS = 'ExperimenterGroupWrapper'
2822
2823 - def simpleMarshal (self, xtra=None, parents=False):
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
2833 - def getRawPreferences (self):
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
2844 - def setRawPreferences (self, prefs):
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
2859 - def getPreference (self, key, default='', section=None):
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
2868 - def getPreferences (self, section=None):
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
2876 - def setPreference (self, key, value, section=None):
2877 if section is None: 2878 section = 'DEFAULT' 2879 prefs = self.getRawPreferences() 2880 if not section in prefs.sections(): 2881 prefs.add_section(section) 2882 prefs.set(section, key, value) 2883 self.setRawPreferences(prefs)
2884
2885 - def getDetails (self):
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
2892 - def getName (self):
2893 return self.omeName
2894
2895 - def getDescription (self):
2896 return self.getFullName()
2897
2898 - def getFullName (self):
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
2915 - def getNameWithInitial(self):
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
2926 - def isAdmin(self):
2927 for ob in self._obj.copyGroupExperimenterMap(): 2928 if ob.parent.name.val == "system": 2929 return True 2930 return False
2931
2932 - def isActive(self):
2933 for ob in self._obj.copyGroupExperimenterMap(): 2934 if ob.parent.name.val == "user": 2935 return True 2936 return False
2937
2938 - def isGuest(self):
2939 for ob in self._obj.copyGroupExperimenterMap(): 2940 if ob.parent.name.val == "guest": 2941 return True 2942 return False
2943 2944 ExperimenterWrapper = _ExperimenterWrapper
2945 2946 -class _ExperimenterGroupWrapper (BlitzObjectWrapper):
2947 """ 2948 omero_model_ExperimenterGroupI class wrapper extends BlitzObjectWrapper. 2949 """ 2950
2951 - def __bstrap__ (self):
2952 self.OMERO_CLASS = 'ExperimenterGroup' 2953 self.LINK_CLASS = "copyGroupExperimenterMap" 2954 self.CHILD_WRAPPER_CLASS = 'ExperimenterWrapper' 2955 self.PARENT_WRAPPER_CLASS = None
2956
2957 - def isLeader(self):
2958 if self._conn.getEventContext().groupId in self._conn.getEventContext().leaderOfGroups: 2959 return True 2960 return False
2961 2962 ExperimenterGroupWrapper = _ExperimenterGroupWrapper
2963 2964 -class DetailsWrapper (BlitzObjectWrapper):
2965 """ 2966 omero_model_DetailsI class wrapper extends BlitzObjectWrapper. 2967 """ 2968
2969 - def __init__ (self, *args, **kwargs):
2970 super(DetailsWrapper, self).__init__ (*args, **kwargs) 2971 owner = self._obj.getOwner() 2972 group = self._obj.getGroup() 2973 self._owner = owner and ExperimenterWrapper(self._conn, self._obj.getOwner()) or None 2974 self._group = group and ExperimenterGroupWrapper(self._conn, self._obj.getGroup()) or None
2975
2976 - def getOwner (self):
2977 return self._owner
2978
2979 - def getGroup (self):
2980 return self._group
2981
2982 -class _DatasetWrapper (BlitzObjectWrapper):
2983 """ 2984 omero_model_DatasetI class wrapper extends BlitzObjectWrapper. 2985 """ 2986
2987 - def __bstrap__ (self):
2988 self.OMERO_CLASS = 'Dataset' 2989 self.LINK_CLASS = "DatasetImageLink" 2990 self.CHILD_WRAPPER_CLASS = 'ImageWrapper' 2991 self.PARENT_WRAPPER_CLASS = 'ProjectWrapper'
2992
2993 - def __loadedHotSwap__ (self):
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
3001 3002 -class _ProjectWrapper (BlitzObjectWrapper):
3003 """ 3004 omero_model_ProjectI class wrapper extends BlitzObjectWrapper. 3005 """ 3006
3007 - def __bstrap__ (self):
3008 self.OMERO_CLASS = 'Project' 3009 self.LINK_CLASS = "ProjectDatasetLink" 3010 self.CHILD_WRAPPER_CLASS = 'DatasetWrapper' 3011 self.PARENT_WRAPPER_CLASS = None
3012 3013 ProjectWrapper = _ProjectWrapper
3014 3015 -class _ScreenWrapper (BlitzObjectWrapper):
3016 3017 annotation_counter = None 3018
3019 - def __bstrap__ (self):
3020 self.OMERO_CLASS = 'Screen' 3021 self.LINK_CLASS = "ScreenPlateLink" 3022 self.CHILD_WRAPPER_CLASS = 'PlateWrapper' 3023 self.PARENT_WRAPPER_CLASS = None
3024 3025 ScreenWrapper = _ScreenWrapper
3026 3027 -class _PlateWrapper (BlitzObjectWrapper):
3028 3029 annotation_counter = None 3030
3031 - def __bstrap__ (self):
3032 self.OMERO_CLASS = 'Plate' 3033 self.LINK_CLASS = None 3034 self.CHILD_WRAPPER_CLASS = None 3035 self.PARENT_WRAPPER_CLASS = 'ScreenWrapper'
3036 3037 PlateWrapper = _PlateWrapper
3038 3039 -class _WellWrapper (BlitzObjectWrapper):
3040
3041 - def __bstrap__ (self):
3042 self.OMERO_CLASS = 'Well' 3043 self.LINK_CLASS = "WellSample" 3044 self.CHILD_WRAPPER_CLASS = "ImageWrapper" 3045 self.PARENT_WRAPPER_CLASS = 'PlateWrapper'
3046
3047 - def __prepare__ (self, **kwargs):
3048 try: 3049 self.index = int(kwargs['index']) 3050 except: 3051 self.index = 0
3052
3053 - def isWellSample (self):
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
3062 - def countWellSample (self):
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
3072 - def selectedWellSample (self):
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
3081 - def loadWellSamples (self):
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
3089 - def plate(self):
3090 return PlateWrapper(self._conn, self._obj.plate)
3091 3092 WellWrapper = _WellWrapper
3093 3094 -class _WellSampleWrapper (BlitzObjectWrapper):
3095
3096 - def __bstrap__ (self):
3097 self.OMERO_CLASS = 'WellSample' 3098 self.CHILD_WRAPPER_CLASS = "ImageWrapper" 3099 self.PARENT_WRAPPER_CLASS = 'WellWrapper'
3100
3101 - def image(self):
3102 return ImageWrapper(self._conn, self._obj.image)
3103 3104 WellSampleWrapper = _WellSampleWrapper
3105 3106 -class _ShareWrapper (BlitzObjectWrapper):
3107
3108 - def getStartDate(self):
3109 return datetime.fromtimestamp(self.getStarted().val/1000)
3110
3111 - def getExpirationDate(self):
3112 try: 3113 return datetime.fromtimestamp((self.getStarted().val+self.getTimeToLive().val)/1000) 3114 except ValueError: 3115 pass 3116 return None
3117
3118 - def isExpired(self):
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
3127 - def isOwned(self):
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
3135 - def getOwner(self):
3136 return omero.gateway.ExperimenterWrapper(self, self.owner)
3137 3138 ShareWrapper = _ShareWrapper
3139 3140 -class ShareContentWrapper (BlitzObjectWrapper):
3141 pass
3142
3143 -class ShareCommentWrapper (AnnotationWrapper):
3144 pass
3145
3146 ## IMAGE ## 3147 3148 -class ColorHolder (object):
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
3155 - def __init__ (self, colorname=None):
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
3161 - def fromRGBA(klass,r,g,b,a):
3162 rv = klass() 3163 rv.setRed(r) 3164 rv.setGreen(g) 3165 rv.setBlue(b) 3166 rv.setAlpha(a) 3167 return rv
3168
3169 - def getRed (self):
3170 return self._color['red']
3171
3172 - def setRed (self, val):
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
3181 - def getGreen (self):
3182 return self._color['green']
3183
3184 - def setGreen (self, val):
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
3193 - def getBlue (self):
3194 return self._color['blue']
3195
3196 - def setBlue (self, val):
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
3205 - def getAlpha (self):
3206 return self._color['alpha']
3207
3208 - def setAlpha (self, val):
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
3216 - def getHtml (self):
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
3223 - def getCss (self):
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
3232 - def getRGB (self):
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
3239 -class _LogicalChannelWrapper (BlitzObjectWrapper):
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
3264 3265 -class _LightPathWrapper (BlitzObjectWrapper):
3266 """ 3267 base Light Source class wrapper, extends BlitzObjectWrapper. 3268 """ 3269 _attrs = ('dichroic|DichroicWrapper') 3270 # 'copyEmissionFilter|FilterWrapper', 3271 # 'copyExcitationFilter|FilterWrapper', 3272
3273 - def __bstrap__ (self):
3274 self.OMERO_CLASS = 'LightPath'
3275
3276 - def copyEmissionFilters(self):
3277 pass
3278
3279 - def copyExcitationFilters(self):
3280 pass
3281 3282 LightPathWrapper = _LightPathWrapper
3283 3284 -class _ChannelWrapper (BlitzObjectWrapper):
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
3300 - def __bstrap__ (self):
3301 self.OMERO_CLASS = 'Channel'
3302
3303 - def __prepare__ (self, idx=-1, re=None, img=None):
3304 self._re = re 3305 self._idx = idx 3306 self._img = img
3307
3308 - def save (self):
3309 self._obj.setPixels(omero.model.PixelsI(self._obj.getPixels().getId(), False)) 3310 return super(_ChannelWrapper, self).save()
3311
3312 - def isActive (self):
3313 return self._re.isActive(self._idx)
3314
3315 - def getLogicalChannel (self):
3316 if self._obj.logicalChannel is not None: 3317 return LogicalChannelWrapper(self._conn, self._obj.logicalChannel)
3318
3319 - def getEmissionWave (self):
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
3328 - def getColor (self):
3329 return ColorHolder.fromRGBA(*self._re.getRGBA(self._idx))
3330
3331 - def getWindowStart (self):
3332 return int(self._re.getChannelWindowStart(self._idx))
3333
3334 - def setWindowStart (self, val):
3335 self.setWindow(val, self.getWindowEnd())
3336
3337 - def getWindowEnd (self):
3338 return int(self._re.getChannelWindowEnd(self._idx))
3339
3340 - def setWindowEnd (self, val):
3341 self.setWindow(self.getWindowStart(), val)
3342
3343 - def setWindow (self, minval, maxval):
3344 self._re.setChannelWindow(self._idx, float(minval), float(maxval))
3345
3346 - def getWindowMin (self):
3347 return self._obj.getStatsInfo().getGlobalMin().val
3348
3349 - def getWindowMax (self):
3350 return self._obj.getStatsInfo().getGlobalMax().val
3351 3352 ChannelWrapper = _ChannelWrapper
3353 3354 -def assert_re (func):
3355 def wrapped (self, *args, **kwargs): 3356 if not self._prepareRenderingEngine(): 3357 return None 3358 return func(self, *args, **kwargs)
3359 return wrapped 3360
3361 -def assert_pixels (func):
3362 def wrapped (self, *args, **kwargs): 3363 if not self._loadPixels(): 3364 return None 3365 return func(self, *args, **kwargs)
3366 return wrapped 3367
3368 3369 -class _ImageWrapper (BlitzObjectWrapper):
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 # projection 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
3391 - def fromPixelsId (self, conn, pid):
3392 q = conn.getQueryService() 3393 p = q.find('Pixels', pid) 3394 if p is None: 3395 return None 3396 return ImageWrapper(conn, p.image)
3397
3398 - def __bstrap__ (self):
3399 self.OMERO_CLASS = 'Image' 3400 self.LINK_CLASS = None 3401 self.CHILD_WRAPPER_CLASS = None 3402 self.PARENT_WRAPPER_CLASS = 'DatasetWrapper'
3403
3404 - def __del__ (self):
3405 self._re and self._re.untaint()
3406
3407 - def __loadedHotSwap__ (self):
3408 self._obj = self._conn.getContainerService().getImages(self.OMERO_CLASS, (self._oid,), None)[0]
3409
3410 - def getInstrument (self):
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
3437 - def _loadPixels (self):
3438 if not self._obj.pixelsLoaded: 3439 self.__loadedHotSwap__() 3440 return self._obj.sizeOfPixels() > 0
3441
3442 - def _prepareRE (self):
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: #pragma: no cover 3447 try: 3448 re.resetDefaults() 3449 except omero.ResourceError: 3450 # broken image 3451 return False 3452 re.lookupRenderingDef(pixels_id) 3453 re.load() 3454 return re
3455
3456 - def _prepareRenderingEngine (self):
3457 self._loadPixels() 3458 if self._re is None: 3459 if self._obj.sizeOfPixels() < 1: 3460 return False 3461 if self._pd is None: 3462 self._pd = omero.romio.PlaneDef(self.PLANEDEF) 3463 self._re = self._prepareRE() 3464 return self._re is not None
3465
3466 - def resetRDefs (self):
3467 logger.debug('resetRDefs') 3468 if self.canWrite(): 3469 self._conn.getDeleteService().deleteSettings(self.getId()) 3470 return True 3471 return False
3472
3473 - def simpleMarshal (self, xtra=None, parents=False):
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
3485 - def getStageLabel (self):
3486 if self._obj.stageLabel is None: 3487 return None 3488 else: 3489 return ImageStageLabelWrapper(self._conn, self._obj.stageLabel)
3490
3491 - def shortname(self, length=20, hist=5):
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
3500 - def getAuthor(self):
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
3506 - def getDataset(self):
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: #pragma: no cover 3516 logger.debug('on getDataset') 3517 logger.debug(traceback.format_exc()) 3518 return None
3519
3520 - def getProject(self):
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: #pragma: no cover 3530 logger.debug('on getProject') 3531 logger.debug(traceback.format_exc()) 3532 return None
3533
3534 - def getDate(self):
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: # pragma: no cover 3540 logger.debug('on getDate') 3541 logger.debug(traceback.format_exc()) 3542 #self._date = "Today" 3543 return datetime.fromtimestamp(event.time.val / 1000) #"Today"
3544
3545 - def getObjectiveSettings (self):
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
3553 - def getImagingEnvironment (self):
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
3562 - def getPrimaryPixels (self):
3563 return self._obj.getPrimaryPixels()
3564 3565 @assert_pixels
3566 - def getPixelsId (self):
3567 return self._obj.getPrimaryPixels().getId().val
3568
3569 - def _prepareTB (self):
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: #pragma: no cover 3580 tb.resetDefaults() 3581 tb.close() 3582 tb.setPixelsId(pixels_id) 3583 return tb
3584
3585 - def loadOriginalMetadata(self):
3586 global_metadata = list() 3587 series_metadata = list() 3588 if self is not None: 3589 for a in self.listAnnotations(): 3590 if isinstance(a._obj, FileAnnotationI) and a.isOriginalMetadata(): 3591 t_file = list() 3592 for piece in a.getFileInChunks(): 3593 t_file.append(piece) 3594 temp_file = "".join(t_file).split('\n') 3595 flag = None 3596 for l in temp_file: 3597 if l.startswith("[GlobalMetadata]"): 3598 flag = 1 3599 elif l.startswith("[SeriesMetadata]"): 3600 flag = 2 3601 else: 3602 if len(l) < 1: 3603 l = None 3604 else: 3605 l = tuple(l.split("=")) 3606 if l is not None: 3607 if flag == 1: 3608 global_metadata.append(l) 3609 elif flag == 2: 3610 series_metadata.append(l) 3611 return (a, (global_metadata), (series_metadata)) 3612 return None
3613
3614 - def getThumbnail (self, size=(64,64), z=None, t=None):
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: #pragma: no cover 3641 logger.error(traceback.print_exc()) 3642 return None
3643 3644 @assert_pixels
3645 - def getPixelRange (self):
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
3658 - def getChannels (self):
3659 return [ChannelWrapper(self._conn, c, idx=n, re=self._re, img=self) for n,c in enumerate(self._re.getPixels().iterateChannels())]
3660
3661 - def setActiveChannels(self, channels, windows=None, colors=None):
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
3673 - def getProjections (self):
3674 return self.PROJECTIONS.keys()
3675
3676 - def setProjection (self, proj):
3677 self._pr = proj
3678 3679 LINE_PLOT_DTYPES = { 3680 (4, True, True): 'f', # signed float 3681 (2, False, False): 'H', # unsigned short 3682 (2, False, True): 'h', # signed short 3683 (1, False, False): 'B', # unsigned char 3684 (1, False, True): 'b', # signed char 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() # TODO: Assuming ours is a little endian system 3724 # now move data into the windowMin..windowMax range 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):
3738 return self.getPixelLine(z,t,y,'h',channels,range)
3739
3740 - def getCol (self, z, t, x, channels=None, range=None):
3741 return self.getPixelLine(z,t,x,'v',channels,range)
3742 3743 @assert_re
3744 - def getRenderingModels (self):
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
3751 - def getRenderingModel (self):
3752 return BlitzObjectWrapper(self._conn, self._re.getModel())
3753
3754 - def setGreyscaleRenderingModel (self):
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
3762 - def setColorRenderingModel (self):
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
3770 - def isGreyscaleRenderingModel (self):
3771 return self.getRenderingModel().value.lower() == 'greyscale'
3772 3773 @assert_re
3774 - def renderJpeg (self, z, t, compression=0.9):
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: #pragma: no cover 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: #pragma: no cover 3793 logger.debug('On renderJpeg'); 3794 logger.debug(traceback.format_exc()) 3795 return None 3796 except Ice.MemoryLimitException: #pragma: no cover 3797 # Make sure renderCompressed isn't called again on this re, as it hangs 3798 self._obj.clearPixels() 3799 self._obj.pixelsLoaded = False 3800 self._re = None 3801 raise
3802
3803 - def exportOmeTiff (self):
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
3816 - def renderImage (self, z, t, compression=0.9):
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
3823 - def renderSplitChannel (self, z, t, compression=0.9, border=2):
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
3840 - def splitChannelDims (self, border=2):
3841 c = self.c_count() 3842 # Greyscale, no channel overlayed image 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 # Color, one extra image with all channels overlayed 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
3870 - def renderSplitChannelImage (self, z, t, compression=0.9, border=2):
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 # Font sizes depends on image width 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: #pragma: no cover 3899 fsize = 18 3900 elif w >= 298: #pragma: no cover 3901 fsize = 14 3902 elif w >= 256: #pragma: no cover 3903 fsize = 12 3904 elif w >= 213: #pragma: no cover 3905 fsize = 10 3906 elif w >= 96: #pragma: no cover 3907 fsize = 8 3908 else: #pragma: no cover 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 # Some color 3940 LP_BGCOLOR = 1 # Black 3941 LP_FGCOLOR = 2 # white
3942 - def prepareLinePlotCanvas (self, z, t):
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 # Prepare the palette taking channel colors in consideration 3953 for channel in channels: 3954 pal.extend(channel.getColor().getRGB()) 3955 3956 # Prepare the PIL classes we'll be using 3957 im = Image.new('P', (width, height)) 3958 im.putpalette(pal) 3959 return im, width, height
3960 3961 3962 @assert_re
3963 - def renderRowLinePlotGif (self, z, t, y, linewidth=1):
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 # On your marks, get set... go! 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 # Grab row data 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
3991 - def renderColLinePlotGif (self, z, t, x, linewidth=1):
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 # On your marks, get set... go! 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 # Grab col data 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
4018 - def getZ (self):
4019 return self._pd.z
4020 4021 @assert_re
4022 - def getT (self):
4023 return self._pd.t
4024 4025 @assert_pixels
4026 - def getPixelSizeX (self):
4027 rv = self._obj.getPrimaryPixels().getPhysicalSizeX() 4028 return rv is not None and rv.val or 0
4029 4030 @assert_pixels
4031 - def getPixelSizeY (self):
4032 rv = self._obj.getPrimaryPixels().getPhysicalSizeY() 4033 return rv is not None and rv.val or 0
4034 4035 @assert_pixels
4036 - def getPixelSizeZ (self):
4037 rv = self._obj.getPrimaryPixels().getPhysicalSizeZ() 4038 return rv is not None and rv.val or 0
4039 4040 @assert_pixels
4041 - def getWidth (self):
4042 return self._obj.getPrimaryPixels().getSizeX().val
4043 4044 @assert_pixels
4045 - def getHeight (self):
4046 return self._obj.getPrimaryPixels().getSizeY().val
4047 4048 @assert_pixels
4049 - def z_count (self):
4050 return self._obj.getPrimaryPixels().getSizeZ().val
4051 4052 @assert_pixels
4053 - def t_count (self):
4054 return self._obj.getPrimaryPixels().getSizeT().val
4055 4056 @assert_pixels
4057 - def c_count (self):
4058 return self._obj.getPrimaryPixels().getSizeC().val
4059
4060 - def clearDefaults (self):
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
4079 - def saveDefaults (self):
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
4093 4094 ## INSTRUMENT AND ACQUISITION ## 4095 4096 -class _ImageStageLabelWrapper (BlitzObjectWrapper):
4097 pass
4098 4099 ImageStageLabelWrapper = _ImageStageLabelWrapper
4100 4101 -class _ImagingEnvironmentWrapper(BlitzObjectWrapper):
4102 pass
4103 4104 ImagingEnvironmentWrapper = _ImagingEnvironmentWrapper
4105 4106 -class _ImagingEnviromentWrapper (BlitzObjectWrapper):
4107 """ 4108 omero_model_ImagingEnvironmentI class wrapper extends BlitzObjectWrapper. 4109 """ 4110 _attrs = ('temperature', 4111 'airPressure', 4112 'humidity', 4113 'co2percent', 4114 'version') 4115
4116 - def __bstrap__ (self):
4117 self.OMERO_CLASS = 'ImagingEnvironment'
4118 4119 ImagingEnviromentWrapper = _ImagingEnviromentWrapper
4120 4121 -class _TransmittanceRangeWrapper (BlitzObjectWrapper):
4122 """ 4123 omero_model_TransmittanceRangeI class wrapper extends BlitzObjectWrapper. 4124 """ 4125 _attrs = ('cutIn', 4126 'cutOut', 4127 'cutInTolerance', 4128 'cutOutTolerance', 4129 'transmittance', 4130 'version') 4131
4132 - def __bstrap__ (self):
4133 self.OMERO_CLASS = 'TransmittanceRange'
4134 4135 TransmittanceRangeWrapper = _TransmittanceRangeWrapper
4136 4137 -class _DetectorSettingsWrapper (BlitzObjectWrapper):
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
4149 - def __bstrap__ (self):
4150 self.OMERO_CLASS = 'DetectorSettings'
4151 4152 DetectorSettingsWrapper = _DetectorSettingsWrapper
4153 4154 -class _DetectorWrapper (BlitzObjectWrapper):
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
4169 - def __bstrap__ (self):
4170 self.OMERO_CLASS = 'Detector'
4171
4172 - def getDetectorType(self):
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
4181 4182 -class _ObjectiveWrapper (BlitzObjectWrapper):
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
4198 - def __bstrap__ (self):
4199 self.OMERO_CLASS = 'Objective'
4200
4201 - def getImmersion(self):
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
4209 - def getCorrection(self):
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
4217 - def getIris(self):
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
4226 4227 -class _ObjectiveSettingsWrapper (BlitzObjectWrapper):
4228 """ 4229 omero_model_ObjectiveSettingsI class wrapper extends BlitzObjectWrapper. 4230 """ 4231 _attrs = ('correctionCollar', 4232 '#medium', 4233 'refractiveIndex', 4234 'objective|ObjectiveWrapper', 4235 'version') 4236
4237 - def __bstrap__ (self):
4238 self.OMERO_CLASS = 'ObjectiveSettings'
4239
4240 - def getObjective (self):
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
4248 - def getMedium(self):
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
4257 4258 4259 -class _FilterWrapper (BlitzObjectWrapper):
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
4271 - def __bstrap__ (self):
4272 self.OMERO_CLASS = 'Filter'
4273
4274 - def getFilterType(self):
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
4283 4284 -class _DichroicWrapper (BlitzObjectWrapper):
4285 """ 4286 omero_model_DichroicI class wrapper extends BlitzObjectWrapper. 4287 """ 4288 _attrs = ('manufacturer', 4289 'model', 4290 'lotNumber', 4291 'version') 4292
4293 - def __bstrap__ (self):
4294 self.OMERO_CLASS = 'Dichroic'
4295 4296 DichroicWrapper = _DichroicWrapper
4297 4298 -class _FilterSetWrapper (BlitzObjectWrapper):
4299 """ 4300 omero_model_FilterSetI class wrapper extends BlitzObjectWrapper. 4301 """ 4302 _attrs = ('manufacturer', 4303 'model', 4304 'lotNumber', 4305 #'exFilter|FilterWrapper', 4306 #'emFilter|FilterWrapper', 4307 'dichroic|DichroicWrapper', 4308 'version') 4309
4310 - def __bstrap__ (self):
4311 self.OMERO_CLASS = 'FilterSet'
4312
4313 - def copyEmissionFilters(self):
4314 pass
4315
4316 - def copyExcitationFilters(self):
4317 pass
4318 4319 FilterSetWrapper = _FilterSetWrapper
4320 4321 -class _OTFWrapper (BlitzObjectWrapper):
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
4334 - def __bstrap__ (self):
4335 self.OMERO_CLASS = 'OTF'
4336 4337 OTFWrapper = _OTFWrapper
4338 4339 -class _LightSettingsWrapper (BlitzObjectWrapper):
4340 """ 4341 base Light Source class wrapper, extends BlitzObjectWrapper. 4342 """ 4343 _attrs = ('attenuation', 4344 'wavelength', 4345 'lightSource|LightSourceWrapper', 4346 'microbeamManipulation', 4347 'version') 4348
4349 - def __bstrap__ (self):
4350 self.OMERO_CLASS = 'LightSettings'
4351 4352 LightSettingsWrapper = _LightSettingsWrapper
4353 4354 -class _LightSourceWrapper (BlitzObjectWrapper):
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
4365 - def getLightSourceType(self):
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 = {}
4374 -def LightSourceWrapper (conn, obj, **kwargs):
4375 for k, v in _LightSourceClasses.items(): 4376 if isinstance(obj, k): 4377 return getattr(omero.gateway, v)(conn, obj, **kwargs) 4378 return None
4379
4380 -class _FilamentWrapper (_LightSourceWrapper):
4381 """ 4382 omero_model_ArcI class wrapper extends LightSourceWrapper. 4383 """ 4384
4385 - def __bstrap__ (self):
4386 super(self.__class__, self).__bstrap__() 4387 self.OMERO_CLASS = 'Filament'
4388 4389 FilamentWrapper = _FilamentWrapper 4390 _LightSourceClasses[omero.model.FilamentI] = 'FilamentWrapper'
4391 4392 -class _ArcWrapper (FilamentWrapper):
4393 """ 4394 omero_model_ArcI class wrapper extends FilamentWrapper. 4395 """
4396 - def __bstrap__ (self):
4397 super(self.__class__, self).__bstrap__() 4398 self.OMERO_CLASS = 'Arc'
4399 4400 ArcWrapper = _ArcWrapper 4401 _LightSourceClasses[omero.model.ArcI] = 'ArcWrapper'
4402 4403 -class _LaserWrapper (_LightSourceWrapper):
4404 """ 4405 omero_model_LaserI class wrapper extends LightSourceWrapper. 4406 """
4407 - def __bstrap__ (self):
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
4420 - def getLaserMedium(self):
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'
4430 4431 -class _LightEmittingDiodeWrapper (_LightSourceWrapper):
4432 """ 4433 omero_model_LightEmittingDiodeI class wrapper extends LightSourceWrapper. 4434 """
4435 - def __bstrap__ (self):
4436 super(self.__class__, self).__bstrap__() 4437 self.OMERO_CLASS = 'LightEmittingDiode'
4438 4439 LightEmittingDiodeWrapper = _LightEmittingDiodeWrapper 4440 _LightSourceClasses[omero.model.LightEmittingDiodeI] = 'LightEmittingDiodeWrapper'
4441 4442 -class _MicroscopeWrapper (BlitzObjectWrapper):
4443 """ 4444 omero_model_MicroscopeI class wrapper extends BlitzObjectWrapper. 4445 """ 4446 _attrs = ('manufacturer', 4447 'model', 4448 'serialNumber', 4449 '#type;microscopeType', 4450 'version') 4451
4452 - def __bstrap__ (self):
4453 self.OMERO_CLASS = 'Microscope'
4454
4455 - def getMicroscopeType(self):
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
4464 4465 -class _InstrumentWrapper (BlitzObjectWrapper):
4466 """ 4467 omero_model_InstrumentI class wrapper extends BlitzObjectWrapper. 4468 """ 4469 4470 # TODO: wrap version 4471 4472 _attrs = ('microscope|MicroscopeWrapper',) 4473
4474 - def __bstrap__ (self):
4475 self.OMERO_CLASS = 'Instrument'
4476
4477 - def getMicroscope (self):
4478 if self._obj.microscope is not None: 4479 return MicroscopeWrapper(self._conn, self._obj.microscope) 4480 return None
4481
4482 - def getDetectors (self):
4483 return [DetectorWrapper(self._conn, x) for x in self._detectorSeq]
4484
4485 - def getObjectives (self):
4486 return [ObjectiveWrapper(self._conn, x) for x in self._objectiveSeq]
4487
4488 - def getFilters (self):
4489 return [FilterWrapper(self._conn, x) for x in self._filterSeq]
4490
4491 - def getDichroics (self):
4492 return [DichroicWrapper(self._conn, x) for x in self._dichroicSeq]
4493
4494 - def getFilterSets (self):
4495 return [FilterSetWrapper(self._conn, x) for x in self._filterSetSeq]
4496
4497 - def getOTFs (self):
4498 return [OTFWrapper(self._conn, x) for x in self._otfSeq]
4499
4500 - def getLightSources (self):
4501 return [LightSourceWrapper(self._conn, x) for x in self._lightSourceSeq]
4502 4503
4504 - def simpleMarshal (self):
4505 if self._obj: 4506 rv = super(_InstrumentWrapper, self).simpleMarshal(parents=False) 4507 rv['detectors'] = [x.simpleMarshal() for x in self.getDetectors()] 4508 rv['objectives'] = [x.simpleMarshal() for x in self.getObjectives()] 4509 rv['filters'] = [x.simpleMarshal() for x in self.getFilters()] 4510 rv['dichroics'] = [x.simpleMarshal() for x in self.getDichroics()] 4511 rv['filterSets'] = [x.simpleMarshal() for x in self.getFilterSets()] 4512 rv['otfs'] = [x.simpleMarshal() for x in self.getOTFs()] 4513 rv['lightsources'] = [x.simpleMarshal() for x in self.getLightSources()] 4514 else: 4515 rv = {} 4516 return rv
4517 4518 InstrumentWrapper = _InstrumentWrapper 4519