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 getFreeSpace(self):
1698 """ Returns the free or available space on this file system 1699 including nested subdirectories. """ 1700 1701 rep_serv = self.getRepositoryInfoService() 1702 return rep_serv.getFreeSpaceInKilobytes() * 1024
1703 1704 ############################################## 1705 ## IShare 1706
1707 - def getOwnShares(self):
1708 """ Gets all owned shares for the current user. """ 1709 1710 sh = self.getShareService() 1711 for e in sh.getOwnShares(False): 1712 yield ShareWrapper(self, e)
1713
1714 - def getMemberShares(self):
1715 """ Gets all shares where current user is a member. """ 1716 1717 sh = self.getShareService() 1718 for e in sh.getMemberShares(False): 1719 yield ShareWrapper(self, e)
1720
1721 - def getMemberCount(self, share_ids):
1722 """ Returns a map from share id to the count of total members (including the 1723 owner). This is represented by ome.model.meta.ShareMember links.""" 1724 1725 sh = self.getShareService() 1726 return sh.getMemberCount(share_ids)
1727
1728 - def getCommentCount(self, share_ids):
1729 """ Returns a map from share id to comment count. """ 1730 1731 sh = self.getShareService() 1732 return sh.getCommentCount(share_ids)
1733
1734 - def getContents(self, share_id):
1735 """ Looks up all items belong to the share.""" 1736 1737 sh = self.getShareService() 1738 for e in sh.getContents(long(share_id)): 1739 yield ShareContentWrapper(self, e)
1740
1741 - def getComments(self, share_id):
1742 """ Looks up all comments which belong to the share.""" 1743 1744 sh = self.getShareService() 1745 for e in sh.getComments(long(share_id)): 1746 yield ShareCommentWrapper(self, e)
1747
1748 - def getAllMembers(self, share_id):
1749 """ Get all {@link Experimenter users} who are a member of the share.""" 1750 1751 sh = self.getShareService() 1752 for e in sh.getAllMembers(long(share_id)): 1753 yield ExperimenterWrapper(self, e)
1754
1755 - def getAllGuests(self, share_id):
1756 """ Get the email addresses for all share guests.""" 1757 1758 sh = self.getShareService() 1759 return sh.getAllGuests(long(share_id))
1760
1761 - def getAllUsers(self, share_id):
1762 """ Get a single set containing the login names of the users as well email addresses for guests.""" 1763 1764 sh = self.getShareService() 1765 return sh.getAllUsers(long(share_id))
1766 1767 ############################ 1768 # ITimeline # 1769
1770 - def timelineListImages (self, tfrom=None, tto=None, limit=10, only_owned=True):
1771 """ 1772 List images based on the their creation times. 1773 If both tfrom and tto are None, grab the most recent batch. 1774 1775 @param tfrom: milliseconds since the epoch for start date 1776 @param tto: milliseconds since the epoch for end date 1777 @param tlimit: maximum number of results 1778 @param only_owned: Only owned by the logged user. Boolean. 1779 @return: Generator yielding _ImageWrapper 1780 """ 1781 tm = self.getTimelineService() 1782 p = omero.sys.Parameters() 1783 f = omero.sys.Filter() 1784 if only_owned: 1785 f.ownerId = rlong(self.getEventContext().userId) 1786 f.groupId = rlong(self.getEventContext().groupId) 1787 else: 1788 f.ownerId = rlong(-1) 1789 f.groupId = None 1790 f.limit = rint(limit) 1791 p.theFilter = f 1792 if tfrom is None and tto is None: 1793 for e in tm.getMostRecentObjects(['Image'], p, False)["Image"]: 1794 yield ImageWrapper(self, e) 1795 else: 1796 if tfrom is None: 1797 tfrom = 0 1798 if tto is None: 1799 tto = time.time() * 1000 1800 for e in tm.getByPeriod(['Image'], rtime(long(tfrom)), rtime(long(tto)), p, False)['Image']: 1801 yield ImageWrapper(self, e)
1802 1803 1804 ########################### 1805 # Specific Object Getters # 1806
1807 - def getProject (self, oid):
1808 """ 1809 Return Project for the given ID. 1810 1811 @param oid: Project ID. 1812 @return: _ProjectWrapper or None 1813 """ 1814 1815 q = self.getQueryService() 1816 pr = q.find("Project", long(oid)) 1817 if pr is not None: 1818 pr = ProjectWrapper(self, pr) 1819 return pr
1820
1821 - def findProject (self, name):
1822 """ 1823 Return Project with the given name. 1824 1825 @param name: Project name. 1826 @return: _ProjectWrapper or None 1827 """ 1828 q = self.getQueryService() 1829 params = omero.sys.Parameters() 1830 if not params.map: 1831 params.map = {} 1832 params.map['name'] = rstring(name) 1833 pr = q.findAllByQuery("from Project as p where p.name=:name", params) 1834 if len(pr): 1835 return ProjectWrapper(self, pr[0]) 1836 return None
1837
1838 - def getDataset (self, oid):
1839 """ 1840 Return Dataset for the given ID. 1841 1842 @param oid: Dataset ID. 1843 @return: _DatasetWrapper or None 1844 """ 1845 1846 q = self.getQueryService() 1847 ds = q.find("Dataset", long(oid)) 1848 if ds is not None: 1849 ds = DatasetWrapper(self, ds) 1850 return ds
1851
1852 - def getImage (self, oid):
1853 """ 1854 Return Image for the given ID. 1855 1856 @param oid: Image ID. 1857 @return: _ImageWrapper or None 1858 """ 1859 1860 q = self.getQueryService() 1861 img = q.find("Image", long(oid)) 1862 if img is not None: 1863 img = ImageWrapper(self, img) 1864 return img
1865
1866 - def getShare (self, oid):
1867 """ Gets share for the given share id. """ 1868 1869 sh_serv = self.getShareService() 1870 sh = sh_serv.getShare(long(oid)) 1871 if sh is not None: 1872 return ShareWrapper(self, sh) 1873 else: 1874 return None
1875
1876 - def getScreen (self, oid):
1877 query_serv = self.getQueryService() 1878 p = omero.sys.Parameters() 1879 p.map = {} 1880 p.map["oid"] = rlong(long(oid)) 1881 sql = "select sc from Screen sc join fetch sc.details.owner join fetch sc.details.group where sc.id=:oid " 1882 sc = query_serv.findByQuery(sql,p) 1883 if sc is not None: 1884 return ScreenWrapper(self, sc) 1885 else: 1886 return None
1887
1888 - def getPlate (self, oid):
1889 query_serv = self.getQueryService() 1890 p = omero.sys.Parameters() 1891 p.map = {} 1892 p.map["oid"] = rlong(long(oid)) 1893 sql = "select pl from Plate pl join fetch pl.details.owner join fetch pl.details.group " \ 1894 "left outer join fetch pl.screenLinks spl " \ 1895 "left outer join fetch spl.parent sc where pl.id=:oid " 1896 pl = query_serv.findByQuery(sql,p) 1897 if pl is not None: 1898 return PlateWrapper(self, pl) 1899 else: 1900 return None
1901
1902 - def getSpecifiedImages(self, oids):
1903 query_serv = self.getQueryService() 1904 p = omero.sys.Parameters() 1905 p.map = {} 1906 p.map["ids"] = rlist([rlong(a) for a in oids]) 1907 sql = "select im from Image im join fetch im.details.owner join fetch im.details.group where im.id in (:ids) order by im.name" 1908 for e in query_serv.findAllByQuery(sql, p): 1909 yield ImageWrapper(self, e)
1910
1911 - def getSpecifiedDatasets(self, oids):
1912 query_serv = self.getQueryService() 1913 p = omero.sys.Parameters() 1914 p.map = {} 1915 p.map["ids"] = rlist([rlong(a) for a in oids]) 1916 sql = "select ds from Dataset ds join fetch ds.details.owner join fetch ds.details.group where ds.id in (:ids) order by ds.name" 1917 for e in query_serv.findAllByQuery(sql, p): 1918 yield DatasetWrapper(self, e)
1919
1920 - def getSpecifiedProjects(self, oids):
1921 query_serv = self.getQueryService() 1922 p = omero.sys.Parameters() 1923 p.map = {} 1924 p.map["ids"] = rlist([rlong(a) for a in oids]) 1925 sql = "select pr from Project pr join fetch pr.details.owner join fetch pr.details.group where pr.id in (:ids) order by pr.name" 1926 for e in query_serv.findAllByQuery(sql, p): 1927 yield ProjectWrapper(self, e)
1928
1929 - def getSpecifiedPlates(self, oids):
1930 query_serv = self.getQueryService() 1931 p = omero.sys.Parameters() 1932 p.map = {} 1933 p.map["ids"] = rlist([rlong(a) for a in oids]) 1934 sql = "select pl from Plate pl join fetch pl.details.owner join fetch pl.details.group where pl.id in (:ids) order by pl.name" 1935 for e in query_serv.findAllByQuery(sql, p): 1936 yield DatasetWrapper(self, e)
1937 1938 ################################# 1939 # Annotations # 1940
1941 - def getFileAnnotation (self, oid):
1942 query_serv = self.getQueryService() 1943 p = omero.sys.Parameters() 1944 p.map = {} 1945 p.map["oid"] = rlong(long(oid)) 1946 sql = "select f from FileAnnotation f join fetch f.file where f.id = :oid" 1947 of = query_serv.findByQuery(sql, p) 1948 return FileAnnotationWrapper(self, of)
1949
1950 - def getCommentAnnotation (self, oid):
1951 query_serv = self.getQueryService() 1952 p = omero.sys.Parameters() 1953 p.map = {} 1954 p.map["oid"] = rlong(long(oid)) 1955 sql = "select ca from CommentAnnotation ca where ca.id = :oid" 1956 ta = query_serv.findByQuery(sql, p) 1957 return AnnotationWrapper(self, ta)
1958
1959 - def getTagAnnotation (self, oid):
1960 query_serv = self.getQueryService() 1961 p = omero.sys.Parameters() 1962 p.map = {} 1963 p.map["oid"] = rlong(long(oid)) 1964 sql = "select tg from TagAnnotation tg where tg.id = :oid" 1965 tg = query_serv.findByQuery(sql, p) 1966 return AnnotationWrapper(self, tg)
1967
1968 - def lookupTagAnnotation (self, name):
1969 query_serv = self.getQueryService() 1970 p = omero.sys.Parameters() 1971 p.map = {} 1972 p.map["text"] = rstring(str(name)) 1973 p.map["eid"] = rlong(self.getEventContext().userId) 1974 f = omero.sys.Filter() 1975 f.limit = rint(1) 1976 p.theFilter = f 1977 sql = "select tg from TagAnnotation tg " \ 1978 "where tg.textValue=:text and tg.details.owner.id=:eid and tg.ns is null order by tg.textValue" 1979 tg = query_serv.findByQuery(sql, p) 1980 return AnnotationWrapper(self, tg)
1981 1982 ############################## 1983 # Annotation based iterators # 1984
1985 - def listImages (self, ns, params=None):
1986 """ 1987 TODO: description 1988 1989 @return: Generator yielding _ImageWrapper 1990 """ 1991 1992 if not params: 1993 params = omero.sys.Parameters() 1994 if not params.map: 1995 params.map = {} 1996 params.map["ns"] = omero_type(ns) 1997 query = """ 1998 select i 1999 from Image i 2000 join i.annotationLinks ial 2001 join ial.child as a 2002 where a.ns = :ns 2003 order by a.id desc """ 2004 for i in self.getQueryService().findAllByQuery(query, params): 2005 yield ImageWrapper(self, i)
2006 2007 2008 ################ 2009 # Enumerations # 2010
2011 - def getEnumerationEntries(self, klass):
2012 types = self.getTypesService() 2013 for e in types.allEnumerations(str(klass)): 2014 yield EnumerationWrapper(self, e)
2015
2016 - def getEnumeration(self, klass, string):
2017 types = self.getTypesService() 2018 obj = types.getEnumeration(str(klass), str(string)) 2019 if obj is not None: 2020 return EnumerationWrapper(self, obj) 2021 else: 2022 return None
2023
2024 - def getEnumerationById(self, klass, eid):
2025 query_serv = self.getQueryService() 2026 obj = query_serv.find(klass, long(eid)) 2027 if obj is not None: 2028 return EnumerationWrapper(self, obj) 2029 else: 2030 return None
2031
2032 - def getOriginalEnumerations(self):
2033 types = self.getTypesService() 2034 rv = dict() 2035 for e in types.getOriginalEnumerations(): 2036 if rv.get(e.__class__.__name__) is None: 2037 rv[e.__class__.__name__] = list() 2038 rv[e.__class__.__name__].append(EnumerationWrapper(self, e)) 2039 return rv
2040
2041 - def getEnumerations(self):
2042 types = self.getTypesService() 2043 return types.getEnumerationTypes()
2044
2045 - def getEnumerationsWithEntries(self):
2046 types = self.getTypesService() 2047 rv = dict() 2048 for key, value in types.getEnumerationsWithEntries().items(): 2049 r = list() 2050 for e in value: 2051 r.append(EnumerationWrapper(self, e)) 2052 rv[key+"I"] = r 2053 return rv
2054
2055 - def deleteEnumeration(self, obj):
2056 types = self.getTypesService() 2057 types.deleteEnumeration(obj)
2058
2059 - def createEnumeration(self, obj):
2060 types = self.getTypesService() 2061 types.createEnumeration(obj)
2062
2063 - def resetEnumerations(self, klass):
2064 types = self.getTypesService() 2065 types.resetEnumerations(klass)
2066
2067 - def updateEnumerations(self, new_entries):
2068 types = self.getTypesService() 2069 types.updateEnumerations(new_entries)
2070 2071 ################### 2072 # Delete # 2073
2074 - def deleteObject(self, obj):
2075 u = self.getUpdateService() 2076 u.deleteObject(obj)
2077
2078 - def deleteAnnotation(self, oid, child=None, anns=None):
2079 op = dict() 2080 dc = omero.api.delete.DeleteCommand('/Annotation', long(oid), op) 2081 handle = self.getDeleteService().queueDelete([dc]) 2082 return handle
2083
2084 - def deleteImage(self, oid, anns=None):
2085 op = dict() 2086 if anns is None: 2087 op["/TagAnnotation"] = "KEEP" 2088 op["/TermAnnotation"] = "KEEP" 2089 op["/FileAnnotation"] = "KEEP" 2090 dc = omero.api.delete.DeleteCommand('/Image', long(oid), op) 2091 handle = self.getDeleteService().queueDelete([dc]) 2092 return handle
2093
2094 - def deleteImages(self, ids, anns=None):
2095 op = dict() 2096 if anns is None: 2097 op["/TagAnnotation"] = "KEEP" 2098 op["/TermAnnotation"] = "KEEP" 2099 op["/FileAnnotation"] = "KEEP" 2100 dcs = list() 2101 for i in ids: 2102 dcs.append(omero.api.delete.DeleteCommand('/Image', long(i), op)) 2103 handle = self.getDeleteService().queueDelete(dcs) 2104 return handle
2105
2106 - def deletePlate(self, oid, anns=None):
2107 op = dict() 2108 if anns is None: 2109 op["/TagAnnotation"] = "KEEP" 2110 op["/TermAnnotation"] = "KEEP" 2111 op["/FileAnnotation"] = "KEEP" 2112 dc = omero.api.delete.DeleteCommand('/Plate', long(oid), op) 2113 handle = self.getDeleteService().queueDelete([dc]) 2114 return handle
2115
2116 - def deleteDataset(self, obj, child=None, anns=None):
2117 op = dict() 2118 if anns is None: 2119 op["/TagAnnotation"] = "KEEP" 2120 op["/TermAnnotation"] = "KEEP" 2121 op["/FileAnnotation"] = "KEEP" 2122 if child is None: 2123 op["/Image"] = "KEEP" 2124 dc = omero.api.delete.DeleteCommand('/Dataset', long(obj.id), op) 2125 handle = self.getDeleteService().queueDelete([dc]) 2126 return handle
2127
2128 - def deleteProject(self, obj, child=None, anns=None):
2129 op = dict() 2130 if anns is None: 2131 op["/TagAnnotation"] = "KEEP" 2132 op["/TermAnnotation"] = "KEEP" 2133 op["/FileAnnotation"] = "KEEP" 2134 if child is None: 2135 op["/Dataset"] = "KEEP" 2136 op["/Image"] = "KEEP" 2137 dc = omero.api.delete.DeleteCommand('/Project', long(obj.id), op) 2138 handle = self.getDeleteService().queueDelete([dc]) 2139 return handle
2140
2141 - def deleteScreen(self, obj, child=None, anns=None):
2142 op = dict() 2143 if anns is None: 2144 op["/TagAnnotation"] = "KEEP" 2145 op["/TermAnnotation"] = "KEEP" 2146 op["/FileAnnotation"] = "KEEP" 2147 if child is None: 2148 op["/Plate"] = "KEEP" 2149 dc = omero.api.delete.DeleteCommand('/Screen', long(obj.id), op) 2150 handle = self.getDeleteService().queueDelete([dc]) 2151 return handle
2152 2153 ################### 2154 # Searching stuff # 2155 2156 2157 #def searchImages (self, text): 2158 # """ 2159 # Fulltext search for images 2160 # """ 2161 # return self.simpleSearch(text,(ImageWrapper,)) 2162
2163 - def searchImages (self, text=None, created=None):
2164 search = self.createSearchService() 2165 search.onlyType('Image') 2166 search.addOrderByAsc("name") 2167 if created: 2168 search.onlyCreatedBetween(created[0], created[1]); 2169 if text: 2170 search.setAllowLeadingWildcard(True) 2171 search.byFullText(str(text)) 2172 if search.hasNext(): 2173 for e in search.results(): 2174 yield ImageWrapper(self, e)
2175
2176 - def searchDatasets (self, text=None, created=None):
2177 search = self.createSearchService() 2178 search.onlyType('Dataset') 2179 search.addOrderByAsc("name") 2180 if created: 2181 search.onlyCreatedBetween(created[0], created[1]); 2182 if text: 2183 search.setAllowLeadingWildcard(True) 2184 search.byFullText(str(text)) 2185 2186 if search.hasNext(): 2187 for e in search.results(): 2188 yield DatasetWrapper(self, e)
2189 2190
2191 - def searchProjects (self, text=None, created=None):
2192 search = self.createSearchService() 2193 search.onlyType('Project') 2194 search.addOrderByAsc("name") 2195 if created: 2196 search.onlyCreatedBetween(created[0], created[1]); 2197 if text: 2198 search.setAllowLeadingWildcard(True) 2199 search.byFullText(str(text)) 2200 if search.hasNext(): 2201 for e in search.results(): 2202 yield ProjectWrapper(self, e)
2203
2204 - def searchScreens (self, text=None, created=None):
2205 search = self.createSearchService() 2206 search.onlyType('Screen') 2207 search.addOrderByAsc("name") 2208 if created: 2209 search.onlyCreatedBetween(created[0], created[1]); 2210 if text: 2211 search.setAllowLeadingWildcard(True) 2212 search.byFullText(str(text)) 2213 if search.hasNext(): 2214 for e in search.results(): 2215 yield ScreenWrapper(self, e)
2216
2217 - def searchPlates (self, text=None, created=None):
2218 search = self.createSearchService() 2219 search.onlyType('Plate') 2220 search.addOrderByAsc("name") 2221 if created: 2222 search.onlyCreatedBetween(created[0], created[1]); 2223 if text: 2224 search.setAllowLeadingWildcard(True) 2225 search.byFullText(str(text)) 2226 if search.hasNext(): 2227 for e in search.results(): 2228 yield PlateWrapper(self, e)
2229
2230 - def simpleSearch (self, text, types=None):
2231 """ 2232 Fulltext search on Projects, Datasets and Images. 2233 TODO: search other object types? 2234 TODO: batch support. 2235 """ 2236 if not text: 2237 return [] 2238 if isinstance(text, UnicodeType): 2239 text = text.encode('utf8') 2240 if types is None: 2241 types = (ProjectWrapper, DatasetWrapper, ImageWrapper) 2242 search = self.createSearchService() 2243 if text[0] in ('?','*'): 2244 search.setAllowLeadingWildcard(True) 2245 rv = [] 2246 for t in types: 2247 def actualSearch (): 2248 search.onlyType(t().OMERO_CLASS) 2249 search.byFullText(text)
2250 timeit(actualSearch)() 2251 if search.hasNext(): 2252 def searchProcessing (): 2253 rv.extend(map(lambda x: t(self, x), search.results())) 2254 timeit(searchProcessing)() 2255 search.close() 2256 return rv 2257
2258 -def safeCallWrap (self, attr, f): #pragma: no cover
2259 """ 2260 Captures called function. Throws an exception. 2261 2262 @return: 2263 """ 2264 2265 def inner (*args, **kwargs): 2266 try: 2267 return f(*args, **kwargs) 2268 except omero.ResourceError: 2269 logger.debug('captured resource error') 2270 raise 2271 except omero.SecurityViolation: 2272 raise 2273 except omero.ApiUsageException: 2274 raise 2275 except Ice.MemoryLimitException: 2276 raise 2277 except omero.InternalException: 2278 raise 2279 except Ice.Exception, x: 2280 # Failed 2281 logger.debug( "Ice.Exception (1) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs))) 2282 logger.debug(traceback.format_exc()) 2283 # Recreate the proxy object 2284 try: 2285 self._obj = self._create_func() 2286 func = getattr(self._obj, attr) 2287 return func(*args, **kwargs) 2288 except Ice.MemoryLimitException: 2289 raise 2290 except Ice.Exception, x: 2291 # Still Failed 2292 logger.debug("Ice.Exception (2) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs))) 2293 logger.debug(traceback.format_exc()) 2294 try: 2295 # Recreate connection 2296 self._connect() 2297 logger.debug('last try for %s' % attr) 2298 # Last try, don't catch exception 2299 func = getattr(self._obj, attr) 2300 return func(*args, **kwargs) 2301 except: 2302 raise 2303 2304 def wrapped (*args, **kwargs): #pragma: no cover 2305 try: 2306 return inner(*args, **kwargs) 2307 except Ice.MemoryLimitException: 2308 logger.debug("MemoryLimitException! abort, abort...") 2309 raise 2310 except omero.SecurityViolation: 2311 logger.debug("SecurityViolation, bailing out") 2312 raise 2313 except omero.ApiUsageException: 2314 logger.debug("ApiUsageException, bailing out") 2315 raise 2316 except Ice.UnknownException: 2317 logger.debug("UnknownException, bailing out") 2318 raise 2319 except Ice.Exception, x: 2320 logger.debug('wrapped ' + f.func_name) 2321 logger.debug(x.__dict__) 2322 if x.serverExceptionClass == 'ome.conditions.InternalException': 2323 if x.message.find('java.lang.NullPointerException') > 0: 2324 logger.debug("NullPointerException, bailing out") 2325 raise 2326 elif x.message.find('Session is dirty') >= 0: 2327 logger.debug("Session is dirty, bailing out") 2328 raise 2329 else: 2330 logger.debug(x.message) 2331 logger.debug("exception caught, first time we back off for 10 secs") 2332 logger.debug(traceback.format_exc()) 2333 #time.sleep(10) 2334 return inner(*args, **kwargs) 2335 return wrapped 2336 2337 2338 BlitzGateway = _BlitzGateway
2339 2340 2341 -def splitHTMLColor (color):
2342 """ splits an hex stream of characters into an array of bytes in format (R,G,B,A). 2343 - abc -> (0xAA, 0xBB, 0xCC, 0xFF) 2344 - abcd -> (0xAA, 0xBB, 0xCC, 0xDD) 2345 - abbccd -> (0xAB, 0xBC, 0xCD, 0xFF) 2346 - abbccdde -> (0xAB, 0xBC, 0xCD, 0xDE) 2347 """ 2348 try: 2349 out = [] 2350 if len(color) in (3,4): 2351 c = color 2352 color = '' 2353 for e in c: 2354 color += e + e 2355 if len(color) == 6: 2356 color += 'FF' 2357 if len(color) == 8: 2358 for i in range(0, 8, 2): 2359 out.append(int(color[i:i+2], 16)) 2360 return out 2361 except: 2362 pass 2363 return None
2364
2365 2366 -class ProxyObjectWrapper (object):
2367 - def __init__ (self, conn, func_str):
2368 self._obj = None 2369 self._func_str = func_str 2370 self._resyncConn(conn) 2371 self._tainted = False
2372
2373 - def clone (self):
2374 return ProxyObjectWrapper(self._conn, self._func_str)
2375
2376 - def _connect (self): #pragma: no cover
2377 """ 2378 Returns True if connected. 2379 2380 @return: Boolean 2381 """ 2382 2383 logger.debug("proxy_connect: a"); 2384 if not self._conn.connect(): 2385 logger.debug('connect failed') 2386 logger.debug('/n'.join(traceback.format_stack())) 2387 return False 2388 logger.debug("proxy_connect: b"); 2389 self._resyncConn(self._conn) 2390 logger.debug("proxy_connect: c"); 2391 self._obj = self._create_func() 2392 logger.debug("proxy_connect: d"); 2393 return True
2394
2395 - def taint (self):
2396 self._tainted = True
2397
2398 - def untaint (self):
2399 self._tainted = False
2400
2401 - def close (self):
2402 """ 2403 Closes the underlaying service, so next call to the proxy will create a new 2404 instance of it. 2405 """ 2406 if self._obj and isinstance(self._obj, omero.api.StatefulServiceInterfacePrx): 2407 self._obj.close() 2408 self._obj = None
2409
2410 - def _resyncConn (self, conn):
2411 """ 2412 2413 @param conn: Connection 2414 """ 2415 2416 self._conn = conn 2417 self._sf = conn.c.sf 2418 self._create_func = getattr(self._sf, self._func_str) 2419 if self._obj is not None: 2420 try: 2421 logger.debug("## - refreshing %s" % (self._func_str)) 2422 obj = conn.c.ic.stringToProxy(str(self._obj)) 2423 self._obj = self._obj.checkedCast(obj) 2424 except Ice.ObjectNotExistException: 2425 self._obj = None
2426
2427 - def _getObj (self):
2428 """ 2429 2430 @return: obj 2431 """ 2432 if not self._obj: 2433 self._obj = self._create_func() 2434 else: 2435 self._ping() 2436 return self._obj
2437
2438 - def _ping (self): #pragma: no cover
2439 """ 2440 For some reason, it seems that keepAlive doesn't, so every so often I need to recreate the objects. 2441 2442 @return: Boolean 2443 """ 2444 2445 try: 2446 if not self._sf.keepAlive(self._obj): 2447 logger.debug("... died, recreating ...") 2448 self._obj = self._create_func() 2449 except Ice.ObjectNotExistException: 2450 # The connection is there, but it has been reset, because the proxy no longer exists... 2451 logger.debug("... reset, reconnecting") 2452 self._connect() 2453 return False 2454 except Ice.ConnectionLostException: 2455 # The connection was lost. This shouldn't happen, as we keep pinging it, but does so... 2456 logger.debug(traceback.format_stack()) 2457 logger.debug("... lost, reconnecting") 2458 self._conn._connected = False 2459 self._connect() 2460 return False 2461 except Ice.ConnectionRefusedException: 2462 # The connection was refused. We lost contact with glacier2router... 2463 logger.debug(traceback.format_stack()) 2464 logger.debug("... refused, reconnecting") 2465 self._connect() 2466 return False 2467 except omero.RemovedSessionException: 2468 # Session died on us 2469 logger.debug(traceback.format_stack()) 2470 logger.debug("... session has left the building, reconnecting") 2471 self._connect() 2472 return False 2473 except Ice.UnknownException: 2474 # Probably a wrapped RemovedSession 2475 logger.debug(traceback.format_stack()) 2476 logger.debug("... ice says something bad happened, reconnecting") 2477 self._connect() 2478 return False 2479 return True 2480
2481 - def __getattr__ (self, attr):
2482 """ 2483 2484 @param attr: Connection 2485 @return: rv 2486 """ 2487 # safe call wrapper 2488 obj = self._obj or self._getObj() 2489 rv = getattr(obj, attr) 2490 if callable(rv): 2491 rv = safeCallWrap(self, attr, rv) 2492 #self._conn.updateTimeout() 2493 return rv
2494
2495 2496 -class AnnotationWrapper (BlitzObjectWrapper):
2497 """ 2498 omero_model_AnnotationI class wrapper extends BlitzObjectWrapper. 2499 """ 2500 registry = {} 2501 OMERO_TYPE = None 2502
2503 - def __init__ (self, *args, **kwargs):
2504 super(AnnotationWrapper, self).__init__(*args, **kwargs) 2505 self.link = kwargs.has_key('link') and kwargs['link'] or None 2506 if self._obj is None and self.OMERO_TYPE is not None: 2507 self._obj = self.OMERO_TYPE()
2508
2509 - def __eq__ (self, a):
2510 return type(a) == type(self) and self._obj.id == a._obj.id and self.getValue() == a.getValue() and self.getNs() == a.getNs()
2511 2512 @classmethod
2513 - def _register (klass, regklass):
2514 klass.registry[regklass.OMERO_TYPE] = regklass
2515 2516 @classmethod
2517 - def _wrap (klass, conn, obj, link=None):
2518 if obj.__class__ in klass.registry: 2519 kwargs = dict() 2520 if link is not None: 2521 kwargs['link'] = BlitzObjectWrapper(conn, link) 2522 return klass.registry[obj.__class__](conn, obj, **kwargs) 2523 else: #pragma: no cover 2524 return None
2525 2526 @classmethod 2533
2534 - def getNs (self):
2535 return self._obj.ns is not None and self._obj.ns.val or None
2536
2537 - def setNs (self, val):
2538 self._obj.ns = omero_type(val)
2539
2540 - def getValue (self): #pragma: no cover
2541 raise NotImplementedError
2542
2543 - def setValue (self, val): #pragma: no cover
2544 raise NotImplementedError 2545 2546 from omero_model_FileAnnotationI import FileAnnotationI
2547 2548 -class FileAnnotationWrapper (AnnotationWrapper):
2549 """ 2550 omero_model_FileAnnotatio class wrapper extends AnnotationWrapper. 2551 """ 2552 2553 OMERO_TYPE = FileAnnotationI 2554
2555 - def __loadedHotSwap__ (self):
2556 if not self._obj.file.loaded: 2557 self._obj._file = self._conn.getQueryService().find('OriginalFile', self._obj.file.id.val)
2558
2559 - def getValue (self):
2560 pass
2561
2562 - def setValue (self, val):
2563 pass
2564
2565 - def isOriginalMetadata(self):
2566 self.__loadedHotSwap__() 2567 try: 2568 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"): 2569 return True 2570 except: 2571 logger.info(traceback.format_exc()) 2572 return False
2573
2574 - def getFileSize(self):
2575 return self._obj.file.size.val
2576
2577 - def getFileName(self):
2578 self.__loadedHotSwap__() 2579 return self._obj.file.name.val
2580
2581 - def getFileInChunks(self):
2582 self.__loadedHotSwap__() 2583 store = self._conn.createRawFileStore() 2584 store.setFileId(self._obj.file.id.val) 2585 size = self.getFileSize() 2586 buf = 2621440 2587 if size <= buf: 2588 yield store.read(0,long(size)) 2589 else: 2590 for pos in range(0,long(size),buf): 2591 data = None 2592 if size-pos < buf: 2593 data = store.read(pos, size-pos) 2594 else: 2595 data = store.read(pos, buf) 2596 yield data 2597 store.close()
2598 2599 # def shortTag(self): 2600 # if isinstance(self._obj, TagAnnotationI): 2601 # try: 2602 # name = self._obj.textValue.val 2603 # l = len(name) 2604 # if l < 25: 2605 # return name 2606 # return name[:10] + "..." + name[l - 10:] 2607 # except: 2608 # logger.info(traceback.format_exc()) 2609 # return self._obj.textValue.val 2610 2611 AnnotationWrapper._register(FileAnnotationWrapper) 2612 2613 from omero_model_TimestampAnnotationI import TimestampAnnotationI
2614 2615 -class TimestampAnnotationWrapper (AnnotationWrapper):
2616 """ 2617 omero_model_TimestampAnnotatio class wrapper extends AnnotationWrapper. 2618 """ 2619 2620 OMERO_TYPE = TimestampAnnotationI 2621
2622 - def getValue (self):
2623 return datetime.fromtimestamp(self._obj.timeValue.val / 1000.0)
2624
2625 - def setValue (self, val):
2626 if isinstance(val, datetime): 2627 self._obj.timeValue = rtime(long(time.mktime(val.timetuple())*1000)) 2628 elif isinstance(val, omero.RTime): 2629 self._obj.timeValue = val 2630 else: 2631 self._obj.timeValue = rtime(long(val * 1000))
2632 2633 AnnotationWrapper._register(TimestampAnnotationWrapper) 2634 2635 from omero_model_BooleanAnnotationI import BooleanAnnotationI
2636 2637 -class BooleanAnnotationWrapper (AnnotationWrapper):
2638 """ 2639 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper. 2640 """ 2641 2642 OMERO_TYPE = BooleanAnnotationI 2643
2644 - def getValue (self):
2645 return self._obj.boolValue.val
2646
2647 - def setValue (self, val):
2648 self._obj.boolValue = rbool(not not val)
2649 2650 AnnotationWrapper._register(BooleanAnnotationWrapper) 2651 2652 from omero_model_TagAnnotationI import TagAnnotationI
2653 2654 -class TagAnnotationWrapper (AnnotationWrapper):
2655 """ 2656 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper. 2657 """ 2658 2659 OMERO_TYPE = TagAnnotationI 2660
2661 - def getValue (self):
2662 return self._obj.textValue.val
2663
2664 - def setValue (self, val):
2665 self._obj.textValue = rbool(not not val)
2666 2667 AnnotationWrapper._register(TagAnnotationWrapper) 2668 2669 from omero_model_CommentAnnotationI import CommentAnnotationI
2670 2671 -class CommentAnnotationWrapper (AnnotationWrapper):
2672 """ 2673 omero_model_CommentAnnotationI class wrapper extends AnnotationWrapper. 2674 """ 2675 2676 OMERO_TYPE = CommentAnnotationI 2677
2678 - def getValue (self):
2679 return self._obj.textValue.val
2680
2681 - def setValue (self, val):
2682 self._obj.textValue = omero_type(val)
2683 2684 AnnotationWrapper._register(CommentAnnotationWrapper) 2685 2686 from omero_model_LongAnnotationI import LongAnnotationI
2687 2688 -class LongAnnotationWrapper (AnnotationWrapper):
2689 """ 2690 omero_model_LongAnnotationI class wrapper extends AnnotationWrapper. 2691 """ 2692 OMERO_TYPE = LongAnnotationI 2693
2694 - def getValue (self):
2695 return self._obj.longValue.val
2696
2697 - def setValue (self, val):
2698 self._obj.longValue = rlong(val)
2699 2700 AnnotationWrapper._register(LongAnnotationWrapper) 2701 2702 from omero_model_DoubleAnnotationI import DoubleAnnotationI
2703 2704 -class DoubleAnnotationWrapper (AnnotationWrapper):
2705 """ 2706 omero_model_DoubleAnnotationI class wrapper extends AnnotationWrapper. 2707 """ 2708 OMERO_TYPE = DoubleAnnotationI 2709
2710 - def getValue (self):
2711 return self._obj.doubleValue.val
2712
2713 - def setValue (self, val):
2714 self._obj.doubleValue = rdouble(val)
2715 2716 AnnotationWrapper._register(DoubleAnnotationWrapper) 2717 2718 from omero_model_TermAnnotationI import TermAnnotationI
2719 2720 -class TermAnnotationWrapper (AnnotationWrapper):
2721 """ 2722 omero_model_TermAnnotationI class wrapper extends AnnotationWrapper. 2723 """ 2724 OMERO_TYPE = TermAnnotationI 2725
2726 - def getValue (self):
2727 return self._obj.termValue.val
2728
2729 - def setValue (self, val):
2730 self._obj.termValue = rstring(val)
2731 2732 AnnotationWrapper._register(TermAnnotationWrapper) 2733 2734 from omero_model_XmlAnnotationI import XmlAnnotationI
2735 2736 -class XmlAnnotationWrapper (CommentAnnotationWrapper):
2737 """ 2738 omero_model_XmlAnnotationI class wrapper extends CommentAnnotationWrapper. 2739 """ 2740 OMERO_TYPE = XmlAnnotationI
2741 2742 AnnotationWrapper._register(XmlAnnotationWrapper)
2743 2744 -class _EnumerationWrapper (BlitzObjectWrapper):
2745
2746 - def getType(self):
2747 return self._obj.__class__
2748 2749 EnumerationWrapper = _EnumerationWrapper
2750 2751 -class _ExperimenterWrapper (BlitzObjectWrapper):
2752 """ 2753 omero_model_ExperimenterI class wrapper extends BlitzObjectWrapper. 2754 """ 2755
2756 - def __bstrap__ (self):
2757 self.OMERO_CLASS = 'Experimenter' 2758 self.LINK_CLASS = "copyGroupExperimenterMap" 2759 self.CHILD_WRAPPER_CLASS = None 2760 self.PARENT_WRAPPER_CLASS = 'ExperimenterGroupWrapper'
2761
2762 - def simpleMarshal (self, xtra=None, parents=False):
2763 rv = super(_ExperimenterWrapper, self).simpleMarshal(xtra=xtra, parents=parents) 2764 rv.update({'firstName': self.firstName, 2765 'middleName': self.middleName, 2766 'lastName': self.lastName, 2767 'email': self.email, 2768 'isAdmin': len(filter(lambda x: x.name.val == 'system', self._conn.getAdminService().containedGroups(self.getId()))) == 1, 2769 }) 2770 return rv
2771
2772 - def getRawPreferences (self):
2773 """ Returns the experiments preferences annotation contents, as a ConfigParser instance """ 2774 self._obj.unloadAnnotationLinks() 2775 cp = ConfigParser.SafeConfigParser() 2776 prefs = self.getAnnotation('TODO.changeme.preferences') 2777 if prefs is not None: 2778 prefs = prefs.getValue() 2779 if prefs is not None: 2780 cp.readfp(StringIO(prefs)) 2781 return cp
2782
2783 - def setRawPreferences (self, prefs):
2784 """ Sets the experiments preferences annotation contents, passed in as a ConfigParser instance """ 2785 ann = self.getAnnotation('TODO.changeme.preferences') 2786 t = StringIO() 2787 prefs.write(t) 2788 if ann is None: 2789 ann = CommentAnnotationWrapper() 2790 ann.setNs('TODO.changeme.preferences') 2791 ann.setValue(t.getvalue()) 2792 self.linkAnnotation(ann) 2793 else: 2794 ann.setValue(t.getvalue()) 2795 ann.save() 2796 self._obj.unloadAnnotationLinks()
2797
2798 - def getPreference (self, key, default='', section=None):
2799 if section is None: 2800 section = 'DEFAULT' 2801 try: 2802 return self.getRawPreferences().get(section, key) 2803 except ConfigParser.Error: 2804 return default 2805 return default
2806
2807 - def getPreferences (self, section=None):
2808 if section is None: 2809 section = 'DEFAULT' 2810 prefs = self.getRawPreferences() 2811 if prefs.has_section(section) or section == 'DEFAULT': 2812 return dict(prefs.items(section)) 2813 return {}
2814
2815 - def setPreference (self, key, value, section=None):
2816 if section is None: 2817 section = 'DEFAULT' 2818 prefs = self.getRawPreferences() 2819 if not section in prefs.sections(): 2820 prefs.add_section(section) 2821 prefs.set(section, key, value) 2822 self.setRawPreferences(prefs)
2823
2824 - def getDetails (self):
2825 if not self._obj.details.owner: 2826 details = omero.model.DetailsI() 2827 details.owner = self._obj 2828 self._obj._details = details 2829 return DetailsWrapper(self._conn, self._obj.details)
2830
2831 - def getName (self):
2832 return self.omeName
2833
2834 - def getDescription (self):
2835 return self.getFullName()
2836
2837 - def getFullName (self):
2838 """ 2839 Gets full name of this experimenter. 2840 2841 @return: String or None 2842 """ 2843 2844 try: 2845 if self.middleName is not None and self.middleName != '': 2846 name = "%s %s. %s" % (self.firstName, self.middleName[:1].upper(), self.lastName) 2847 else: 2848 name = "%s %s" % (self.firstName, self.lastName) 2849 except: 2850 logger.error(traceback.format_exc()) 2851 name = self.omeName 2852 return name
2853
2854 - def getNameWithInitial(self):
2855 try: 2856 if self.firstName is not None and self.lastName is not None: 2857 name = "%s. %s" % (self.firstName[:1], self.lastName) 2858 else: 2859 name = self.omeName 2860 except: 2861 logger.error(traceback.format_exc()) 2862 name = self.omeName 2863 return name
2864
2865 - def isAdmin(self):
2866 for ob in self._obj.copyGroupExperimenterMap(): 2867 if ob.parent.name.val == "system": 2868 return True 2869 return False
2870
2871 - def isActive(self):
2872 for ob in self._obj.copyGroupExperimenterMap(): 2873 if ob.parent.name.val == "user": 2874 return True 2875 return False
2876
2877 - def isGuest(self):
2878 for ob in self._obj.copyGroupExperimenterMap(): 2879 if ob.parent.name.val == "guest": 2880 return True 2881 return False
2882 2883 ExperimenterWrapper = _ExperimenterWrapper
2884 2885 -class _ExperimenterGroupWrapper (BlitzObjectWrapper):
2886 """ 2887 omero_model_ExperimenterGroupI class wrapper extends BlitzObjectWrapper. 2888 """ 2889
2890 - def __bstrap__ (self):
2891 self.OMERO_CLASS = 'ExperimenterGroup' 2892 self.LINK_CLASS = "copyGroupExperimenterMap" 2893 self.CHILD_WRAPPER_CLASS = 'ExperimenterWrapper' 2894 self.PARENT_WRAPPER_CLASS = None
2895
2896 - def isLeader(self):
2897 if self._conn.getEventContext().groupId in self._conn.getEventContext().leaderOfGroups: 2898 return True 2899 return False
2900 2901 ExperimenterGroupWrapper = _ExperimenterGroupWrapper
2902 2903 -class DetailsWrapper (BlitzObjectWrapper):
2904 """ 2905 omero_model_DetailsI class wrapper extends BlitzObjectWrapper. 2906 """ 2907
2908 - def __init__ (self, *args, **kwargs):
2909 super(DetailsWrapper, self).__init__ (*args, **kwargs) 2910 owner = self._obj.getOwner() 2911 group = self._obj.getGroup() 2912 self._owner = owner and ExperimenterWrapper(self._conn, self._obj.getOwner()) or None 2913 self._group = group and ExperimenterGroupWrapper(self._conn, self._obj.getGroup()) or None
2914
2915 - def getOwner (self):
2916 return self._owner
2917
2918 - def getGroup (self):
2919 return self._group
2920
2921 -class _DatasetWrapper (BlitzObjectWrapper):
2922 """ 2923 omero_model_DatasetI class wrapper extends BlitzObjectWrapper. 2924 """ 2925
2926 - def __bstrap__ (self):
2927 self.OMERO_CLASS = 'Dataset' 2928 self.LINK_CLASS = "DatasetImageLink" 2929 self.CHILD_WRAPPER_CLASS = 'ImageWrapper' 2930 self.PARENT_WRAPPER_CLASS = 'ProjectWrapper'
2931
2932 - def __loadedHotSwap__ (self):
2933 super(_DatasetWrapper, self).__loadedHotSwap__() 2934 if not self._obj.isImageLinksLoaded(): 2935 links = self._conn.getQueryService().findAllByQuery("select l from DatasetImageLink as l join fetch l.child as a where l.parent.id=%i" % (self._oid), None) 2936 self._obj._imageLinksLoaded = True 2937 self._obj._imageLinksSeq = links
2938 2939 DatasetWrapper = _DatasetWrapper
2940 2941 -class _ProjectWrapper (BlitzObjectWrapper):
2942 """ 2943 omero_model_ProjectI class wrapper extends BlitzObjectWrapper. 2944 """ 2945
2946 - def __bstrap__ (self):
2947 self.OMERO_CLASS = 'Project' 2948 self.LINK_CLASS = "ProjectDatasetLink" 2949 self.CHILD_WRAPPER_CLASS = 'DatasetWrapper' 2950 self.PARENT_WRAPPER_CLASS = None
2951 2952 ProjectWrapper = _ProjectWrapper
2953 2954 -class _ScreenWrapper (BlitzObjectWrapper):
2955 2956 annotation_counter = None 2957
2958 - def __bstrap__ (self):
2959 self.OMERO_CLASS = 'Screen' 2960 self.LINK_CLASS = "ScreenPlateLink" 2961 self.CHILD_WRAPPER_CLASS = 'PlateWrapper' 2962 self.PARENT_WRAPPER_CLASS = None
2963 2964 ScreenWrapper = _ScreenWrapper
2965 2966 -class _PlateWrapper (BlitzObjectWrapper):
2967 2968 annotation_counter = None 2969
2970 - def __bstrap__ (self):
2971 self.OMERO_CLASS = 'Plate' 2972 self.LINK_CLASS = None 2973 self.CHILD_WRAPPER_CLASS = None 2974 self.PARENT_WRAPPER_CLASS = 'ScreenWrapper'
2975 2976 PlateWrapper = _PlateWrapper
2977 2978 -class _WellWrapper (BlitzObjectWrapper):
2979
2980 - def __bstrap__ (self):
2981 self.OMERO_CLASS = 'Well' 2982 self.LINK_CLASS = "WellSample" 2983 self.CHILD_WRAPPER_CLASS = "ImageWrapper" 2984 self.PARENT_WRAPPER_CLASS = 'PlateWrapper'
2985
2986 - def __prepare__ (self, **kwargs):
2987 try: 2988 self.index = int(kwargs['index']) 2989 except: 2990 self.index = 0
2991
2992 - def isWellSample (self):
2993 """ return boolean if object exist """ 2994 if getattr(self, 'isWellSamplesLoaded')(): 2995 childnodes = getattr(self, 'copyWellSamples')() 2996 logger.debug('listChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes))) 2997 if len(childnodes) > 0: 2998 return True 2999 return False
3000
3001 - def countWellSample (self):
3002 """ return boolean if object exist """ 3003 if getattr(self, 'isWellSamplesLoaded')(): 3004 childnodes = getattr(self, 'copyWellSamples')() 3005 logger.debug('countChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes))) 3006 size = len(childnodes) 3007 if size > 0: 3008 return size 3009 return 0
3010
3011 - def selectedWellSample (self):
3012 """ return a wrapped child object """ 3013 if getattr(self, 'isWellSamplesLoaded')(): 3014 childnodes = getattr(self, 'copyWellSamples')() 3015 logger.debug('listSelectedChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes))) 3016 if len(childnodes) > 0: 3017 return WellSampleWrapper(self._conn, childnodes[self.index]) 3018 return None
3019
3020 - def loadWellSamples (self):
3021 """ return a generator yielding child objects """ 3022 if getattr(self, 'isWellSamplesLoaded')(): 3023 childnodes = getattr(self, 'copyWellSamples')() 3024 logger.debug('listChildren for %s %d: already loaded, %d samples' % (self.OMERO_CLASS, self.getId(), len(childnodes))) 3025 for ch in childnodes: 3026 yield WellSampleWrapper(self._conn, ch)
3027
3028 - def plate(self):
3029 return PlateWrapper(self._conn, self._obj.plate)
3030 3031 WellWrapper = _WellWrapper
3032 3033 -class _WellSampleWrapper (BlitzObjectWrapper):
3034
3035 - def __bstrap__ (self):
3036 self.OMERO_CLASS = 'WellSample' 3037 self.CHILD_WRAPPER_CLASS = "ImageWrapper" 3038 self.PARENT_WRAPPER_CLASS = 'WellWrapper'
3039
3040 - def image(self):
3041 return ImageWrapper(self._conn, self._obj.image)
3042 3043 WellSampleWrapper = _WellSampleWrapper
3044 3045 -class _ShareWrapper (BlitzObjectWrapper):
3046
3047 - def getStartDate(self):
3048 return datetime.fromtimestamp(self.getStarted().val/1000)
3049
3050 - def getExpirationDate(self):
3051 try: 3052 return datetime.fromtimestamp((self.getStarted().val+self.getTimeToLive().val)/1000) 3053 except ValueError: 3054 pass 3055 return None
3056
3057 - def isExpired(self):
3058 try: 3059 if (self.getStarted().val+self.getTimeToLive().val)/1000 <= time.time(): 3060 return True 3061 else: 3062 return False 3063 except: 3064 return True
3065
3066 - def isOwned(self):
3067 try: 3068 if self.owner.id.val == self._conn.getEventContext().userId: 3069 return True 3070 except: 3071 logger.error(traceback.format_exc()) 3072 return False
3073
3074 - def getOwner(self):
3075 return omero.gateway.ExperimenterWrapper(self, self.owner)
3076 3077 ShareWrapper = _ShareWrapper
3078 3079 -class ShareContentWrapper (BlitzObjectWrapper):
3080 pass
3081
3082 -class ShareCommentWrapper (AnnotationWrapper):
3083 pass
3084
3085 ## IMAGE ## 3086 3087 -class ColorHolder (object):
3088 """ 3089 Stores color internally as (R,G,B,A) and allows setting and getting in multiple formats 3090 """ 3091 3092 _color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255} 3093
3094 - def __init__ (self, colorname=None):
3095 self._color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255} 3096 if colorname and colorname.lower() in self._color.keys(): 3097 self._color[colorname.lower()] = 255
3098 3099 @classmethod
3100 - def fromRGBA(klass,r,g,b,a):
3101 rv = klass() 3102 rv.setRed(r) 3103 rv.setGreen(g) 3104 rv.setBlue(b) 3105 rv.setAlpha(a) 3106 return rv
3107
3108 - def getRed (self):
3109 return self._color['red']
3110
3111 - def setRed (self, val):
3112 """ 3113 Set red, as int 0..255 3114 3115 @param val: value of Red. 3116 """ 3117 3118 self._color['red'] = max(min(255, int(val)), 0)
3119
3120 - def getGreen (self):
3121 return self._color['green']
3122
3123 - def setGreen (self, val):
3124 """ 3125 Set green, as int 0..255 3126 3127 @param val: value of Green. 3128 """ 3129 3130 self._color['green'] = max(min(255, int(val)), 0)
3131
3132 - def getBlue (self):
3133 return self._color['blue']
3134
3135 - def setBlue (self, val):
3136 """ 3137 Set Blue, as int 0..255 3138 3139 @param val: value of Blue. 3140 """ 3141 3142 self._color['blue'] = max(min(255, int(val)), 0)
3143
3144 - def getAlpha (self):
3145 return self._color['alpha']
3146
3147 - def setAlpha (self, val):
3148 """ 3149 Set alpha, as int 0..255. 3150 @param val: value of alpha. 3151 """ 3152 3153 self._color['alpha'] = max(min(255, int(val)), 0)
3154
3155 - def getHtml (self):
3156 """ 3157 @return: String. The html usable color. Dumps the alpha information. 3158 """ 3159 3160 return "%(red)0.2X%(green)0.2X%(blue)0.2X" % (self._color)
3161
3162 - def getCss (self):
3163 """ 3164 @return: String. rgba(r,g,b,a) for this color. 3165 """ 3166 3167 c = self._color.copy() 3168 c['alpha'] /= 255.0 3169 return "rgba(%(red)i,%(green)i,%(blue)i,%(alpha)0.3f)" % (c)
3170
3171 - def getRGB (self):
3172 """ 3173 @return: list. A list of (r,g,b) values 3174 """ 3175 3176 return (self._color['red'], self._color['green'], self._color['blue'])
3177
3178 -class _LogicalChannelWrapper (BlitzObjectWrapper):
3179 """ 3180 omero_model_LogicalChannelI class wrapper extends BlitzObjectWrapper. 3181 """ 3182 _attrs = ('name', 3183 'pinHoleSize', 3184 '#illumination', 3185 'contrastMethod', 3186 'excitationWave', 3187 'emissionWave', 3188 'fluor', 3189 'ndFilter', 3190 'otf', 3191 'detectorSettings|DetectorSettingsWrapper', 3192 'lightSourceSettings|LightSettingsWrapper', 3193 'filterSet|FilterSetWrapper', 3194 'lightPath|LightPathWrapper', 3195 'samplesPerPixel', 3196 '#photometricInterpretation', 3197 'mode', 3198 'pockelCellSetting', 3199 'shapes', 3200 'version')
3201 3202 LogicalChannelWrapper = _LogicalChannelWrapper
3203 3204 -class _LightPathWrapper (BlitzObjectWrapper):
3205 """ 3206 base Light Source class wrapper, extends BlitzObjectWrapper. 3207 """ 3208 _attrs = ('dichroic|DichroicWrapper') 3209 # 'copyEmissionFilter|FilterWrapper', 3210 # 'copyExcitationFilter|FilterWrapper', 3211
3212 - def __bstrap__ (self):
3213 self.OMERO_CLASS = 'LightPath'
3214
3215 - def copyEmissionFilters(self):
3216 pass
3217
3218 - def copyExcitationFilters(self):
3219 pass
3220 3221 LightPathWrapper = _LightPathWrapper
3222 3223 -class _ChannelWrapper (BlitzObjectWrapper):
3224 """ 3225 omero_model_ChannelI class wrapper extends BlitzObjectWrapper. 3226 """ 3227 3228 BLUE_MIN = 400 3229 BLUE_MAX = 500 3230 GREEN_MIN = 501 3231 GREEN_MAX = 600 3232 RED_MIN = 601 3233 RED_MAX = 700 3234 COLOR_MAP = ((BLUE_MIN, BLUE_MAX, ColorHolder('Blue')), 3235 (GREEN_MIN, GREEN_MAX, ColorHolder('Green')), 3236 (RED_MIN, RED_MAX, ColorHolder('Red')), 3237 ) 3238
3239 - def __bstrap__ (self):
3240 self.OMERO_CLASS = 'Channel'
3241
3242 - def __prepare__ (self, idx=-1, re=None, img=None):
3243 self._re = re 3244 self._idx = idx 3245 self._img = img
3246
3247 - def save (self):
3248 self._obj.setPixels(omero.model.PixelsI(self._obj.getPixels().getId(), False)) 3249 return super(_ChannelWrapper, self).save()
3250
3251 - def isActive (self):
3252 return self._re.isActive(self._idx)
3253
3254 - def getLogicalChannel (self):
3255 if self._obj.logicalChannel is not None: 3256 return LogicalChannelWrapper(self._conn, self._obj.logicalChannel)
3257
3258 - def getEmissionWave (self):
3259 lc = self.getLogicalChannel() 3260 rv = lc.name 3261 if rv is None: 3262 rv = lc.emissionWave 3263 if rv is None: 3264 rv = self._idx 3265 return rv
3266
3267 - def getColor (self):
3268 return ColorHolder.fromRGBA(*self._re.getRGBA(self._idx))
3269
3270 - def getWindowStart (self):
3271 return int(self._re.getChannelWindowStart(self._idx))
3272
3273 - def setWindowStart (self, val):
3274 self.setWindow(val, self.getWindowEnd())
3275
3276 - def getWindowEnd (self):
3277 return int(self._re.getChannelWindowEnd(self._idx))
3278
3279 - def setWindowEnd (self, val):
3280 self.setWindow(self.getWindowStart(), val)
3281
3282 - def setWindow (self, minval, maxval):
3283 self._re.setChannelWindow(self._idx, float(minval), float(maxval))
3284
3285 - def getWindowMin (self):
3286 return self._obj.getStatsInfo().getGlobalMin().val
3287
3288 - def getWindowMax (self):
3289 return self._obj.getStatsInfo().getGlobalMax().val
3290 3291 ChannelWrapper = _ChannelWrapper
3292 3293 -def assert_re (func):
3294 def wrapped (self, *args, **kwargs): 3295 if not self._prepareRenderingEngine(): 3296 return None 3297 return func(self, *args, **kwargs)
3298 return wrapped 3299
3300 -def assert_pixels (func):
3301 def wrapped (self, *args, **kwargs): 3302 if not self._loadPixels(): 3303 return None 3304 return func(self, *args, **kwargs)
3305 return wrapped 3306
3307 3308 -class _ImageWrapper (BlitzObjectWrapper):
3309 """ 3310 omero_model_ImageI class wrapper extends BlitzObjectWrapper. 3311 """ 3312 3313 _re = None 3314 _pd = None 3315 _rm = {} 3316 _pixels = None 3317 3318 _pr = None # projection 3319 3320 PROJECTIONS = { 3321 'normal': -1, 3322 'intmax': omero.constants.projection.ProjectionType.MAXIMUMINTENSITY, 3323 'intmean': omero.constants.projection.ProjectionType.MEANINTENSITY, 3324 'intsum': omero.constants.projection.ProjectionType.SUMINTENSITY, 3325 } 3326 3327 PLANEDEF = omero.romio.XY 3328 3329 @classmethod
3330 - def fromPixelsId (self, conn, pid):
3331 q = conn.getQueryService() 3332 p = q.find('Pixels', pid) 3333 if p is None: 3334 return None 3335 return ImageWrapper(conn, p.image)
3336
3337 - def __bstrap__ (self):
3338 self.OMERO_CLASS = 'Image' 3339 self.LINK_CLASS = None 3340 self.CHILD_WRAPPER_CLASS = None 3341 self.PARENT_WRAPPER_CLASS = 'DatasetWrapper'
3342
3343 - def __del__ (self):
3344 self._re and self._re.untaint()
3345
3346 - def __loadedHotSwap__ (self):
3347 self._obj = self._conn.getContainerService().getImages(self.OMERO_CLASS, (self._oid,), None)[0]
3348
3349 - def getInstrument (self):
3350 i = self._obj.instrument 3351 if i is None: 3352 return None 3353 if not i.loaded: 3354 self._obj.instrument = self._conn.getQueryService().find('Instrument', i.id.val) 3355 i = self._obj.instrument 3356 meta_serv = self._conn.getMetadataService() 3357 instruments = meta_serv.loadInstrument(i.id.val) 3358 3359 if instruments._detectorLoaded: 3360 i._detectorSeq.extend(instruments._detectorSeq) 3361 if instruments._objectiveLoaded: 3362 i._objectiveSeq.extend(instruments._objectiveSeq) 3363 if instruments._lightSourceLoaded: 3364 i._lightSourceSeq.extend(instruments._lightSourceSeq) 3365 if instruments._filterLoaded: 3366 i._filterSeq.extend(instruments._filterSeq) 3367 if instruments._dichroicLoaded: 3368 i._dichroicSeq.extend(instruments._dichroicSeq) 3369 if instruments._filterSetLoaded: 3370 i._filterSetSeq.extend(instruments._filterSetSeq) 3371 if instruments._otfLoaded: 3372 i._otfSeq.extend(instruments._otfSeq) 3373 3374 return InstrumentWrapper(self._conn, i)
3375
3376 - def _loadPixels (self):
3377 if not self._obj.pixelsLoaded: 3378 self.__loadedHotSwap__() 3379 return self._obj.sizeOfPixels() > 0
3380
3381 - def _prepareRE (self):
3382 re = self._conn.createRenderingEngine() 3383 pixels_id = self._obj.getPrimaryPixels().id.val 3384 re.lookupPixels(pixels_id) 3385 if re.lookupRenderingDef(pixels_id) == False: #pragma: no cover 3386 try: 3387 re.resetDefaults() 3388 except omero.ResourceError: 3389 # broken image 3390 return False 3391 re.lookupRenderingDef(pixels_id) 3392 re.load() 3393 return re
3394
3395 - def _prepareRenderingEngine (self):
3396 self._loadPixels() 3397 if self._re is None: 3398 if self._obj.sizeOfPixels() < 1: 3399 return False 3400 if self._pd is None: 3401 self._pd = omero.romio.PlaneDef(self.PLANEDEF) 3402 self._re = self._prepareRE() 3403 return self._re is not None
3404
3405 - def resetRDefs (self):
3406 logger.debug('resetRDefs') 3407 if self.canWrite(): 3408 self._conn.getDeleteService().deleteSettings(self.getId()) 3409 return True 3410 return False
3411
3412 - def simpleMarshal (self, xtra=None, parents=False):
3413 rv = super(_ImageWrapper, self).simpleMarshal(xtra=xtra, parents=parents) 3414 rv.update({'author': self.getAuthor(), 3415 'date': time.mktime(self.getDate().timetuple()),}) 3416 if xtra: 3417 if xtra.has_key('thumbUrlPrefix'): 3418 if callable(xtra['thumbUrlPrefix']): 3419 rv['thumb_url'] = xtra['thumbUrlPrefix'](str(self.id)) 3420 else: 3421 rv['thumb_url'] = xtra['thumbUrlPrefix'] + str(self.id) + '/' 3422 return rv
3423
3424 - def getStageLabel (self):
3425 if self._obj.stageLabel is None: 3426 return None 3427 else: 3428 return ImageStageLabelWrapper(self._conn, self._obj.stageLabel)
3429
3430 - def shortname(self, length=20, hist=5):
3431 name = self.name 3432 if not name: 3433 return "" 3434 l = len(name) 3435 if l < length+hist: 3436 return name 3437 return "..." + name[l - length:]
3438
3439 - def getAuthor(self):
3440 q = self._conn.getQueryService() 3441 e = q.findByQuery("select e from Experimenter e where e.id = %i" % self._obj.details.owner.id.val,None) 3442 self._author = e.firstName.val + " " + e.lastName.val 3443 return self._author
3444
3445 - def getDataset(self):
3446 try: 3447 q = """ 3448 select ds from Image i join i.datasetLinks dl join dl.parent ds 3449 where i.id = %i 3450 """ % self._obj.id.val 3451 query = self._conn.getQueryService() 3452 ds = query.findByQuery(q,None) 3453 return ds and DatasetWrapper(self._conn, ds) or None 3454 except: #pragma: no cover 3455 logger.debug('on getDataset') 3456 logger.debug(traceback.format_exc()) 3457 return None
3458
3459 - def getProject(self):
3460 try: 3461 q = """ 3462 select p from Image i join i.datasetLinks dl join dl.parent ds join ds.projectLinks pl join pl.parent p 3463 where i.id = %i 3464 """ % self._obj.id.val 3465 query = self._conn.getQueryService() 3466 prj = query.findByQuery(q,None) 3467 return prj and ProjectWrapper(self._conn, prj) or None 3468 except: #pragma: no cover 3469 logger.debug('on getProject') 3470 logger.debug(traceback.format_exc()) 3471 return None
3472
3473 - def getDate(self):
3474 try: 3475 query = self._conn.getQueryService() 3476 event = query.findByQuery("select e from Event e where id = %i" % self._obj.details.creationEvent.id.val, None) 3477 return datetime.fromtimestamp(event.time.val / 1000) 3478 except: # pragma: no cover 3479 logger.debug('on getDate') 3480 logger.debug(traceback.format_exc()) 3481 #self._date = "Today" 3482 return datetime.fromtimestamp(event.time.val / 1000) #"Today"
3483
3484 - def getObjectiveSettings (self):
3485 rv = self.objectiveSettings 3486 if self.objectiveSettings is not None: 3487 rv = ObjectiveSettingsWrapper(self._conn, self.objectiveSettings) 3488 if not self.objectiveSettings.loaded: 3489 self.objectiveSettings = rv._obj 3490 return rv
3491
3492 - def getImagingEnvironment (self):
3493 rv = self.imagingEnvironment 3494 if self.imagingEnvironment is not None: 3495 rv = ImagingEnvironmentWrapper(self._conn, self.imagingEnvironment) 3496 if not self.imagingEnvironment.loaded: 3497 self.imagingEnvironment = rv._obj 3498 return rv
3499 3500 @assert_pixels
3501 - def getPrimaryPixels (self):
3502 return self._obj.getPrimaryPixels()
3503 3504 @assert_pixels
3505 - def getPixelsId (self):
3506 return self._obj.getPrimaryPixels().getId().val
3507
3508 - def _prepareTB (self):
3509 pixels_id = self.getPixelsId() 3510 if pixels_id is None: 3511 return None 3512 tb = self._conn.createThumbnailStore() 3513 try: 3514 rv = tb.setPixelsId(pixels_id) 3515 except omero.InternalException: 3516 logger.error(traceback.print_exc()) 3517 rv = False 3518 if not rv: #pragma: no cover 3519 tb.resetDefaults() 3520 tb.close() 3521 tb.setPixelsId(pixels_id) 3522 return tb
3523
3524 - def loadOriginalMetadata(self):
3525 global_metadata = list() 3526 series_metadata = list() 3527 if self is not None: 3528 for a in self.listAnnotations(): 3529 if isinstance(a._obj, FileAnnotationI) and a.isOriginalMetadata(): 3530 t_file = list() 3531 for piece in a.getFileInChunks(): 3532 t_file.append(piece) 3533 temp_file = "".join(t_file).split('\n') 3534 flag = None 3535 for l in temp_file: 3536 if l.startswith("[GlobalMetadata]"): 3537 flag = 1 3538 elif l.startswith("[SeriesMetadata]"): 3539 flag = 2 3540 else: 3541 if len(l) < 1: 3542 l = None 3543 else: 3544 l = tuple(l.split("=")) 3545 if l is not None: 3546 if flag == 1: 3547 global_metadata.append(l) 3548 elif flag == 2: 3549 series_metadata.append(l) 3550 return (a, (global_metadata), (series_metadata)) 3551 return None
3552
3553 - def getThumbnail (self, size=(64,64), z=None, t=None):
3554 try: 3555 tb = self._prepareTB() 3556 if tb is None: 3557 return None 3558 if isinstance(size, IntType): 3559 size = (size,) 3560 if z is not None and t is not None: 3561 pos = z,t 3562 else: 3563 pos = None 3564 if len(size) == 1: 3565 if pos is None: 3566 thumb = tb.getThumbnailByLongestSideDirect 3567 else: 3568 thumb = tb.getThumbnailForSectionByLongestSideDirect 3569 else: 3570 if pos is None: 3571 thumb = tb.getThumbnailDirect 3572 else: 3573 thumb = tb.getThumbnailForSectionDirect 3574 args = map(lambda x: rint(x), size) 3575 if pos is not None: 3576 args = list(pos) + args 3577 rv = thumb(*args) 3578 return rv 3579 except Exception: #pragma: no cover 3580 logger.error(traceback.print_exc()) 3581 return None
3582 3583 @assert_pixels
3584 - def getPixelRange (self):
3585 """ Returns (min, max) values for the pixels type of this image. 3586 TODO: Does not handle floats correctly, though.""" 3587 pixels_id = self._obj.getPrimaryPixels().getId().val 3588 rp = self._conn.createRawPixelsStore() 3589 rp.setPixelsId(pixels_id, True) 3590 pmax = 2 ** (8 * rp.getByteWidth()) 3591 if rp.isSigned(): 3592 return (-(pmax / 2), pmax / 2 - 1) 3593 else: 3594 return (0, pmax-1)
3595 3596 @assert_re
3597 - def getChannels (self):
3598 return [ChannelWrapper(self._conn, c, idx=n, re=self._re, img=self) for n,c in enumerate(self._re.getPixels().iterateChannels())]
3599
3600 - def setActiveChannels(self, channels, windows=None, colors=None):
3601 for c in range(len(self.getChannels())): 3602 self._re.setActive(c, (c+1) in channels) 3603 if (c+1) in channels: 3604 if windows is not None and windows[c][0] is not None and windows[c][1] is not None: 3605 self._re.setChannelWindow(c, *windows[c]) 3606 if colors is not None and colors[c]: 3607 rgba = splitHTMLColor(colors[c]) 3608 if rgba: 3609 self._re.setRGBA(c, *rgba) 3610 return True
3611
3612 - def getProjections (self):
3613 return self.PROJECTIONS.keys()
3614
3615 - def setProjection (self, proj):
3616 self._pr = proj
3617 3618 LINE_PLOT_DTYPES = { 3619 (4, True, True): 'f', # signed float 3620 (2, False, False): 'H', # unsigned short 3621 (2, False, True): 'h', # signed short 3622 (1, False, False): 'B', # unsigned char 3623 (1, False, True): 'b', # signed char 3624 } 3625
3626 - def getPixelLine (self, z, t, pos, axis, channels=None, range=None):
3627 """ 3628 Grab a horizontal or vertical line from the image pixel data, for the specified channels 3629 (or all if not specified) and using the specified range (or 1:1 relative to the image size). 3630 Axis may be 'h' or 'v', for horizontal or vertical respectively. 3631 3632 @param z: 3633 @param t: 3634 @param pos: 3635 @param axis: 3636 @param channels: 3637 @param range: 3638 @return: rv 3639 """ 3640 3641 if not self._loadPixels(): 3642 logger.debug( "No pixels!") 3643 return None 3644 axis = axis.lower()[:1] 3645 if channels is None: 3646 channels = map(lambda x: x._idx, filter(lambda x: x.isActive(), self.getChannels())) 3647 if range is None: 3648 range = axis == 'h' and self.getHeight() or self.getWidth() 3649 if not isinstance(channels, (TupleType, ListType)): 3650 channels = (channels,) 3651 chw = map(lambda x: (x.getWindowMin(), x.getWindowMax()), self.getChannels()) 3652 rv = [] 3653 pixels_id = self._obj.getPrimaryPixels().getId().val 3654 rp = self._conn.createRawPixelsStore() 3655 rp.setPixelsId(pixels_id, True) 3656 for c in channels: 3657 bw = rp.getByteWidth() 3658 key = self.LINE_PLOT_DTYPES.get((bw, rp.isFloat(), rp.isSigned()), None) 3659 if key is None: 3660 logger.error("Unknown data type: " + str((bw, rp.isFloat(), rp.isSigned()))) 3661 plot = array.array(key, axis == 'h' and rp.getRow(pos, z, c, t) or rp.getCol(pos, z, c, t)) 3662 plot.byteswap() # TODO: Assuming ours is a little endian system 3663 # now move data into the windowMin..windowMax range 3664 offset = -chw[c][0] 3665 if offset != 0: 3666 plot = map(lambda x: x+offset, plot) 3667 normalize = 1.0/chw[c][1]*(range-1) 3668 if normalize != 1.0: 3669 plot = map(lambda x: x*normalize, plot) 3670 if isinstance(plot, array.array): 3671 plot = plot.tolist() 3672 rv.append(plot) 3673 return rv
3674 3675
3676 - def getRow (self, z, t, y, channels=None, range=None):
3677 return self.getPixelLine(z,t,y,'h',channels,range)
3678
3679 - def getCol (self, z, t, x, channels=None, range=None):
3680 return self.getPixelLine(z,t,x,'v',channels,range)
3681 3682 @assert_re
3683 - def getRenderingModels (self):
3684 if not len(self._rm): 3685 for m in [BlitzObjectWrapper(self._conn, m) for m in self._re.getAvailableModels()]: 3686 self._rm[m.value.lower()] = m 3687 return self._rm.values()
3688 3689 @assert_re
3690 - def getRenderingModel (self):
3691 return BlitzObjectWrapper(self._conn, self._re.getModel())
3692
3693 - def setGreyscaleRenderingModel (self):
3694 """ 3695 Sets the Greyscale rendering model on this image's current renderer 3696 """ 3697 3698 rm = self.getRenderingModels() 3699 self._re.setModel(self._rm.get('greyscale', rm[0])._obj)
3700
3701 - def setColorRenderingModel (self):
3702 """ 3703 Sets the HSB rendering model on this image's current renderer 3704 """ 3705 3706 rm = self.getRenderingModels() 3707 self._re.setModel(self._rm.get('rgb', rm[0])._obj)
3708
3709 - def isGreyscaleRenderingModel (self):
3710 return self.getRenderingModel().value.lower() == 'greyscale'
3711 3712 @assert_re
3713 - def renderJpeg (self, z, t, compression=0.9):
3714 self._pd.z = long(z) 3715 self._pd.t = long(t) 3716 try: 3717 if compression is not None: 3718 try: 3719 self._re.setCompressionLevel(float(compression)) 3720 except omero.SecurityViolation: #pragma: no cover 3721 self._obj.clearPixels() 3722 self._obj.pixelsLoaded = False 3723 self._re = None 3724 return self.renderJpeg(z,t,None) 3725 projection = self.PROJECTIONS.get(self._pr, -1) 3726 if not isinstance(projection, omero.constants.projection.ProjectionType): 3727 rv = self._re.renderCompressed(self._pd) 3728 else: 3729 rv = self._re.renderProjectedCompressed(projection, self._pd.t, 1, 0, self.z_count()-1) 3730 return rv 3731 except omero.InternalException: #pragma: no cover 3732 logger.debug('On renderJpeg'); 3733 logger.debug(traceback.format_exc()) 3734 return None 3735 except Ice.MemoryLimitException: #pragma: no cover 3736 # Make sure renderCompressed isn't called again on this re, as it hangs 3737 self._obj.clearPixels() 3738 self._obj.pixelsLoaded = False 3739 self._re = None 3740 raise
3741
3742 - def exportOmeTiff (self):
3743 e = self._conn.createExporter() 3744 e.addImage(self.getId()) 3745 size = e.generateTiff() 3746 p = 0 3747 rv = '' 3748 while p < size: 3749 s = min(65536, size-p) 3750 rv += e.read(p,s) 3751 p += s 3752 e.close() 3753 return rv
3754
3755 - def renderImage (self, z, t, compression=0.9):
3756 rv = self.renderJpeg(z,t,compression) 3757 if rv is not None: 3758 i = StringIO(rv) 3759 rv = Image.open(i) 3760 return rv
3761
3762 - def renderSplitChannel (self, z, t, compression=0.9, border=2):
3763 """ 3764 Prepares a jpeg representation of a 2d grid holding a render of each channel, 3765 along with one for all channels at the set Z and T points. 3766 3767 @param z: 3768 @param t: 3769 @param compression: 3770 @param border: 3771 @return: value 3772 """ 3773 3774 img = self.renderSplitChannelImage(z,t,compression, border) 3775 rv = StringIO() 3776 img.save(rv, 'jpeg', quality=int(compression*100)) 3777 return rv.getvalue()
3778
3779 - def splitChannelDims (self, border=2):
3780 c = self.c_count() 3781 # Greyscale, no channel overlayed image 3782 x = sqrt(c) 3783 y = int(round(x)) 3784 if x > y: 3785 x = y+1 3786 else: 3787 x = y 3788 rv = {'g':{'width': self.getWidth()*x + border*(x+1), 3789 'height': self.getHeight()*y+border*(y+1), 3790 'border': border, 3791 'gridx': x, 3792 'gridy': y,} 3793 } 3794 # Color, one extra image with all channels overlayed 3795 c += 1 3796 x = sqrt(c) 3797 y = int(round(x)) 3798 if x > y: 3799 x = y+1 3800 else: 3801 x = y 3802 rv['c'] = {'width': self.getWidth()*x + border*(x+1), 3803 'height': self.getHeight()*y+border*(y+1), 3804 'border': border, 3805 'gridx': x, 3806 'gridy': y,} 3807 return rv
3808
3809 - def renderSplitChannelImage (self, z, t, compression=0.9, border=2):
3810 """ 3811 Prepares a PIL Image with a 2d grid holding a render of each channel, 3812 along with one for all channels at the set Z and T points. 3813 3814 @param z: 3815 @param t: 3816 @param compression: 3817 @param border: 3818 @return: canvas 3819 """ 3820 3821 dims = self.splitChannelDims(border=border)[self.isGreyscaleRenderingModel() and 'g' or 'c'] 3822 canvas = Image.new('RGBA', (dims['width'], dims['height']), '#fff') 3823 cmap = [ch.isActive() and i+1 or 0 for i,ch in enumerate(self.getChannels())] 3824 c = self.c_count() 3825 pxc = 0 3826 px = dims['border'] 3827 py = dims['border'] 3828 3829 # Font sizes depends on image width 3830 w = self.getWidth() 3831 if w >= 640: 3832 fsize = (int((w-640)/128)*8) + 24 3833 if fsize > 64: 3834 fsize = 64 3835 elif w >= 512: 3836 fsize = 24 3837 elif w >= 384: #pragma: no cover 3838 fsize = 18 3839 elif w >= 298: #pragma: no cover 3840 fsize = 14 3841 elif w >= 256: #pragma: no cover 3842 fsize = 12 3843 elif w >= 213: #pragma: no cover 3844 fsize = 10 3845 elif w >= 96: #pragma: no cover 3846 fsize = 8 3847 else: #pragma: no cover 3848 fsize = 0 3849 if fsize > 0: 3850 font = ImageFont.load('%s/pilfonts/B%0.2d.pil' % (THISPATH, fsize) ) 3851 3852 3853 for i in range(c): 3854 if cmap[i]: 3855 self.setActiveChannels((i+1,)) 3856 img = self.renderImage(z,t, compression) 3857 if fsize > 0: 3858 draw = ImageDraw.ImageDraw(img) 3859 draw.text((2,2), "%s" % (str(self.getChannels()[i].getEmissionWave())), font=font, fill="#fff") 3860 canvas.paste(img, (px, py)) 3861 pxc += 1 3862 if pxc < dims['gridx']: 3863 px += self.getWidth() + border 3864 else: 3865 pxc = 0 3866 px = border 3867 py += self.getHeight() + border 3868 if not self.isGreyscaleRenderingModel(): 3869 self.setActiveChannels(cmap) 3870 img = self.renderImage(z,t, compression) 3871 if fsize > 0: 3872 draw = ImageDraw.ImageDraw(img) 3873 draw.text((2,2), "merged", font=font, fill="#fff") 3874 canvas.paste(img, (px, py)) 3875 return canvas
3876 3877 LP_PALLETE = [0,0,0,0,0,0,255,255,255] 3878 LP_TRANSPARENT = 0 # Some color 3879 LP_BGCOLOR = 1 # Black 3880 LP_FGCOLOR = 2 # white
3881 - def prepareLinePlotCanvas (self, z, t):
3882 """ 3883 Common part of horizontal and vertical line plot rendering. 3884 @returns: (Image, width, height). 3885 """ 3886 channels = filter(lambda x: x.isActive(), self.getChannels()) 3887 width = self.getWidth() 3888 height = self.getHeight() 3889 3890 pal = list(self.LP_PALLETE) 3891 # Prepare the palette taking channel colors in consideration 3892 for channel in channels: 3893 pal.extend(channel.getColor().getRGB()) 3894 3895 # Prepare the PIL classes we'll be using 3896 im = Image.new('P', (width, height)) 3897 im.putpalette(pal) 3898 return im, width, height
3899 3900 3901 @assert_re
3902 - def renderRowLinePlotGif (self, z, t, y, linewidth=1):
3903 self._pd.z = long(z) 3904 self._pd.t = long(t) 3905 3906 im, width, height = self.prepareLinePlotCanvas(z,t) 3907 base = height - 1 3908 3909 draw = ImageDraw.ImageDraw(im) 3910 # On your marks, get set... go! 3911 draw.rectangle([0, 0, width-1, base], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT) 3912 draw.line(((0,y),(width, y)), fill=self.LP_FGCOLOR, width=linewidth) 3913 3914 # Grab row data 3915 rows = self.getRow(z,t,y) 3916 3917 for r in range(len(rows)): 3918 chrow = rows[r] 3919 color = r + self.LP_FGCOLOR + 1 3920 last_point = base-chrow[0] 3921 for i in range(len(chrow)): 3922 draw.line(((i, last_point), (i, base-chrow[i])), fill=color, width=linewidth) 3923 last_point = base-chrow[i] 3924 del draw 3925 out = StringIO() 3926 im.save(out, format="gif", transparency=0) 3927 return out.getvalue()
3928 3929 @assert_re
3930 - def renderColLinePlotGif (self, z, t, x, linewidth=1):
3931 self._pd.z = long(z) 3932 self._pd.t = long(t) 3933 3934 im, width, height = self.prepareLinePlotCanvas(z,t) 3935 3936 draw = ImageDraw.ImageDraw(im) 3937 # On your marks, get set... go! 3938 draw.rectangle([0, 0, width-1, height-1], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT) 3939 draw.line(((x,0),(x, height)), fill=self.LP_FGCOLOR, width=linewidth) 3940 3941 # Grab col data 3942 cols = self.getCol(z,t,x) 3943 3944 for r in range(len(cols)): 3945 chcol = cols[r] 3946 color = r + self.LP_FGCOLOR + 1 3947 last_point = chcol[0] 3948 for i in range(len(chcol)): 3949 draw.line(((last_point, i), (chcol[i], i)), fill=color, width=linewidth) 3950 last_point = chcol[i] 3951 del draw 3952 out = StringIO() 3953 im.save(out, format="gif", transparency=0) 3954 return out.getvalue()
3955 3956 @assert_re
3957 - def getZ (self):
3958 return self._pd.z
3959 3960 @assert_re
3961 - def getT (self):
3962 return self._pd.t
3963 3964 @assert_pixels
3965 - def getPixelSizeX (self):
3966 rv = self._obj.getPrimaryPixels().getPhysicalSizeX() 3967 return rv is not None and rv.val or 0
3968 3969 @assert_pixels
3970 - def getPixelSizeY (self):
3971 rv = self._obj.getPrimaryPixels().getPhysicalSizeY() 3972 return rv is not None and rv.val or 0
3973 3974 @assert_pixels
3975 - def getPixelSizeZ (self):
3976 rv = self._obj.getPrimaryPixels().getPhysicalSizeZ() 3977 return rv is not None and rv.val or 0
3978 3979 @assert_pixels
3980 - def getWidth (self):
3981 return self._obj.getPrimaryPixels().getSizeX().val
3982 3983 @assert_pixels
3984 - def getHeight (self):
3985 return self._obj.getPrimaryPixels().getSizeY().val
3986 3987 @assert_pixels
3988 - def z_count (self):
3989 return self._obj.getPrimaryPixels().getSizeZ().val
3990 3991 @assert_pixels
3992 - def t_count (self):
3993 return self._obj.getPrimaryPixels().getSizeT().val
3994 3995 @assert_pixels
3996 - def c_count (self):
3997 return self._obj.getPrimaryPixels().getSizeC().val
3998
3999 - def clearDefaults (self):
4000 """ 4001 Removes specific color settings from channels 4002 4003 @return: Boolean 4004 """ 4005 4006 if not self.canWrite(): 4007 return False 4008 for c in self.getChannels(): 4009 c.unloadRed() 4010 c.unloadGreen() 4011 c.unloadBlue() 4012 c.unloadAlpha() 4013 c.save() 4014 self._conn.getDeleteService().deleteSettings(self.getId()) 4015 return True
4016 4017 @assert_re
4018 - def saveDefaults (self):
4019 """ 4020 Limited support for saving the current prepared image rendering defs. 4021 Right now only channel colors are saved back. 4022 4023 @return: Boolean 4024 """ 4025 4026 if not self.canWrite(): 4027 return False 4028 self._re.saveCurrentSettings() 4029 return True
4030 4031 ImageWrapper = _ImageWrapper
4032 4033 ## INSTRUMENT AND ACQUISITION ## 4034 4035 -class _ImageStageLabelWrapper (BlitzObjectWrapper):
4036 pass
4037 4038 ImageStageLabelWrapper = _ImageStageLabelWrapper
4039 4040 -class _ImagingEnvironmentWrapper(BlitzObjectWrapper):
4041 pass
4042 4043 ImagingEnvironmentWrapper = _ImagingEnvironmentWrapper
4044 4045 -class _ImagingEnviromentWrapper (BlitzObjectWrapper):
4046 """ 4047 omero_model_ImagingEnvironmentI class wrapper extends BlitzObjectWrapper. 4048 """ 4049 _attrs = ('temperature', 4050 'airPressure', 4051 'humidity', 4052 'co2percent', 4053 'version') 4054
4055 - def __bstrap__ (self):
4056 self.OMERO_CLASS = 'ImagingEnvironment'
4057 4058 ImagingEnviromentWrapper = _ImagingEnviromentWrapper
4059 4060 -class _TransmittanceRangeWrapper (BlitzObjectWrapper):
4061 """ 4062 omero_model_TransmittanceRangeI class wrapper extends BlitzObjectWrapper. 4063 """ 4064 _attrs = ('cutIn', 4065 'cutOut', 4066 'cutInTolerance', 4067 'cutOutTolerance', 4068 'transmittance', 4069 'version') 4070
4071 - def __bstrap__ (self):
4072 self.OMERO_CLASS = 'TransmittanceRange'
4073 4074 TransmittanceRangeWrapper = _TransmittanceRangeWrapper
4075 4076 -class _DetectorSettingsWrapper (BlitzObjectWrapper):
4077 """ 4078 omero_model_DetectorSettingsI class wrapper extends BlitzObjectWrapper. 4079 """ 4080 _attrs = ('voltage', 4081 'gain', 4082 'offsetValue', 4083 'readOutRate', 4084 'binning', 4085 'detector|DetectorWrapper', 4086 'version') 4087
4088 - def __bstrap__ (self):
4089 self.OMERO_CLASS = 'DetectorSettings'
4090 4091 DetectorSettingsWrapper = _DetectorSettingsWrapper
4092 4093 -class _DetectorWrapper (BlitzObjectWrapper):
4094 """ 4095 omero_model_DetectorI class wrapper extends BlitzObjectWrapper. 4096 """ 4097 _attrs = ('manufacturer', 4098 'model', 4099 'serialNumber', 4100 'voltage', 4101 'gain', 4102 'offsetValue', 4103 'zoom', 4104 'amplificationGain', 4105 '#type;detectorType', 4106 'version') 4107
4108 - def __bstrap__ (self):
4109 self.OMERO_CLASS = 'Detector'
4110
4111 - def getDetectorType(self):
4112 rv = self.type 4113 if self.type is not None: 4114 rv = EnumerationWrapper(self._conn, self.type) 4115 if not self.type.loaded: 4116 self.type = rv._obj 4117 return rv
4118 4119 DetectorWrapper = _DetectorWrapper
4120 4121 -class _ObjectiveWrapper (BlitzObjectWrapper):
4122 """ 4123 omero_model_ObjectiveI class wrapper extends BlitzObjectWrapper. 4124 """ 4125 _attrs = ('manufacturer', 4126 'model', 4127 'serialNumber', 4128 'nominalMagnification', 4129 'calibratedMagnification', 4130 'lensNA', 4131 '#immersion', 4132 '#correction', 4133 'workingDistance', 4134 '#iris', 4135 'version') 4136
4137 - def __bstrap__ (self):
4138 self.OMERO_CLASS = 'Objective'
4139
4140 - def getImmersion(self):
4141 rv = self.immersion 4142 if self.immersion is not None: 4143 rv = EnumerationWrapper(self._conn, self.immersion) 4144 if not self.immersion.loaded: 4145 self.immersion = rv._obj 4146 return rv
4147
4148 - def getCorrection(self):
4149 rv = self.correction 4150 if self.correction is not None: 4151 rv = EnumerationWrapper(self._conn, self.correction) 4152 if not self.correction.loaded: 4153 self.correction = rv._obj 4154 return rv
4155
4156 - def getIris(self):
4157 rv = self.iris 4158 if self.iris is not None: 4159 rv = EnumerationWrapper(self._conn, self.iris) 4160 if not self.iris.loaded: 4161 self.iris = rv._obj 4162 return rv
4163 4164 ObjectiveWrapper = _ObjectiveWrapper
4165 4166 -class _ObjectiveSettingsWrapper (BlitzObjectWrapper):
4167 """ 4168 omero_model_ObjectiveSettingsI class wrapper extends BlitzObjectWrapper. 4169 """ 4170 _attrs = ('correctionCollar', 4171 '#medium', 4172 'refractiveIndex', 4173 'objective|ObjectiveWrapper', 4174 'version') 4175
4176 - def __bstrap__ (self):
4177 self.OMERO_CLASS = 'ObjectiveSettings'
4178
4179 - def getObjective (self):
4180 rv = self.objective 4181 if self.objective is not None: 4182 rv = ObjectiveWrapper(self._conn, self.objective) 4183 if not self.objective.loaded: 4184 self.objective = rv._obj 4185 return rv
4186
4187 - def getMedium(self):
4188 rv = self.medium 4189 if self.medium is not None: 4190 rv = EnumerationWrapper(self._conn, self.medium) 4191 if not self.medium.loaded: 4192 self.medium = rv._obj 4193 return rv
4194 4195 ObjectiveSettingsWrapper = _ObjectiveSettingsWrapper
4196 4197 4198 -class _FilterWrapper (BlitzObjectWrapper):
4199 """ 4200 omero_model_FilterI class wrapper extends BlitzObjectWrapper. 4201 """ 4202 _attrs = ('manufacturer', 4203 'model', 4204 'lotNumber', 4205 'filterWheel', 4206 '#type;filterType', 4207 'transmittanceRange|TransmittanceRangeWrapper', 4208 'version') 4209
4210 - def __bstrap__ (self):
4211 self.OMERO_CLASS = 'Filter'
4212
4213 - def getFilterType(self):
4214 rv = self.type 4215 if self.type is not None: 4216 rv = EnumerationWrapper(self._conn, self.type) 4217 if not self.type.loaded: 4218 self.type = rv._obj 4219 return rv
4220 4221 FilterWrapper = _FilterWrapper
4222 4223 -class _DichroicWrapper (BlitzObjectWrapper):
4224 """ 4225 omero_model_DichroicI class wrapper extends BlitzObjectWrapper. 4226 """ 4227 _attrs = ('manufacturer', 4228 'model', 4229 'lotNumber', 4230 'version') 4231
4232 - def __bstrap__ (self):
4233 self.OMERO_CLASS = 'Dichroic'
4234 4235 DichroicWrapper = _DichroicWrapper
4236 4237 -class _FilterSetWrapper (BlitzObjectWrapper):
4238 """ 4239 omero_model_FilterSetI class wrapper extends BlitzObjectWrapper. 4240 """ 4241 _attrs = ('manufacturer', 4242 'model', 4243 'lotNumber', 4244 #'exFilter|FilterWrapper', 4245 #'emFilter|FilterWrapper', 4246 'dichroic|DichroicWrapper', 4247 'version') 4248
4249 - def __bstrap__ (self):
4250 self.OMERO_CLASS = 'FilterSet'
4251
4252 - def copyEmissionFilters(self):
4253 pass
4254
4255 - def copyExcitationFilters(self):
4256 pass
4257 4258 FilterSetWrapper = _FilterSetWrapper
4259 4260 -class _OTFWrapper (BlitzObjectWrapper):
4261 """ 4262 omero_model_OTFI class wrapper extends BlitzObjectWrapper. 4263 """ 4264 _attrs = ('sizeX', 4265 'sizeY', 4266 'opticalAxisAveraged' 4267 'pixelsType', 4268 'path', 4269 'filterSet|FilterSetWrapper', 4270 'objective|ObjectiveWrapper', 4271 'version') 4272
4273 - def __bstrap__ (self):
4274 self.OMERO_CLASS = 'OTF'
4275 4276 OTFWrapper = _OTFWrapper
4277 4278 -class _LightSettingsWrapper (BlitzObjectWrapper):
4279 """ 4280 base Light Source class wrapper, extends BlitzObjectWrapper. 4281 """ 4282 _attrs = ('attenuation', 4283 'wavelength', 4284 'lightSource|LightSourceWrapper', 4285 'microbeamManipulation', 4286 'version') 4287
4288 - def __bstrap__ (self):
4289 self.OMERO_CLASS = 'LightSettings'
4290 4291 LightSettingsWrapper = _LightSettingsWrapper
4292 4293 -class _LightSourceWrapper (BlitzObjectWrapper):
4294 """ 4295 base Light Source class wrapper, extends BlitzObjectWrapper. 4296 """ 4297 _attrs = ('manufacturer', 4298 'model', 4299 'power', 4300 'serialNumber', 4301 '#type;lightSourceType', 4302 'version') 4303
4304 - def getLightSourceType(self):
4305 rv = self.type 4306 if self.type is not None: 4307 rv = EnumerationWrapper(self._conn, self.type) 4308 if not self.type.loaded: 4309 self.type = rv._obj 4310 return rv
4311 4312 _LightSourceClasses = {}
4313 -def LightSourceWrapper (conn, obj, **kwargs):
4314 for k, v in _LightSourceClasses.items(): 4315 if isinstance(obj, k): 4316 return getattr(omero.gateway, v)(conn, obj, **kwargs) 4317 return None
4318
4319 -class _FilamentWrapper (_LightSourceWrapper):
4320 """ 4321 omero_model_ArcI class wrapper extends LightSourceWrapper. 4322 """ 4323
4324 - def __bstrap__ (self):
4325 super(self.__class__, self).__bstrap__() 4326 self.OMERO_CLASS = 'Filament'
4327 4328 FilamentWrapper = _FilamentWrapper 4329 _LightSourceClasses[omero.model.FilamentI] = 'FilamentWrapper'
4330 4331 -class _ArcWrapper (FilamentWrapper):
4332 """ 4333 omero_model_ArcI class wrapper extends FilamentWrapper. 4334 """
4335 - def __bstrap__ (self):
4336 super(self.__class__, self).__bstrap__() 4337 self.OMERO_CLASS = 'Arc'
4338 4339 ArcWrapper = _ArcWrapper 4340 _LightSourceClasses[omero.model.ArcI] = 'ArcWrapper'
4341 4342 -class _LaserWrapper (_LightSourceWrapper):
4343 """ 4344 omero_model_LaserI class wrapper extends LightSourceWrapper. 4345 """
4346 - def __bstrap__ (self):
4347 super(self.__class__, self).__bstrap__() 4348 self.OMERO_CLASS = 'Laser' 4349 self._attrs += ( 4350 '#laserMedium', 4351 'frequencyMultiplication', 4352 'tuneable', 4353 'pulse', 4354 'wavelength', 4355 'pockelCell', 4356 'pump', 4357 'repetitionRate')
4358
4359 - def getLaserMedium(self):
4360 rv = self.laserMedium 4361 if self.laserMedium is not None: 4362 rv = EnumerationWrapper(self._conn, self.laserMedium) 4363 if not self.laserMedium.loaded: 4364 self.laserMedium = rv._obj 4365 return rv
4366 4367 LaserWrapper = _LaserWrapper 4368 _LightSourceClasses[omero.model.LaserI] = 'LaserWrapper'
4369 4370 -class _LightEmittingDiodeWrapper (_LightSourceWrapper):
4371 """ 4372 omero_model_LightEmittingDiodeI class wrapper extends LightSourceWrapper. 4373 """
4374 - def __bstrap__ (self):
4375 super(self.__class__, self).__bstrap__() 4376 self.OMERO_CLASS = 'LightEmittingDiode'
4377 4378 LightEmittingDiodeWrapper = _LightEmittingDiodeWrapper 4379 _LightSourceClasses[omero.model.LightEmittingDiodeI] = 'LightEmittingDiodeWrapper'
4380 4381 -class _MicroscopeWrapper (BlitzObjectWrapper):
4382 """ 4383 omero_model_MicroscopeI class wrapper extends BlitzObjectWrapper. 4384 """ 4385 _attrs = ('manufacturer', 4386 'model', 4387 'serialNumber', 4388 '#type;microscopeType', 4389 'version') 4390
4391 - def __bstrap__ (self):
4392 self.OMERO_CLASS = 'Microscope'
4393
4394 - def getMicroscopeType(self):
4395 rv = self.type 4396 if self.type is not None: 4397 rv = EnumerationWrapper(self._conn, self.type) 4398 if not self.type.loaded: 4399 self.type = rv._obj 4400 return rv
4401 4402 MicroscopeWrapper = _MicroscopeWrapper
4403 4404 -class _InstrumentWrapper (BlitzObjectWrapper):
4405 """ 4406 omero_model_InstrumentI class wrapper extends BlitzObjectWrapper. 4407 """ 4408 4409 # TODO: wrap version 4410 4411 _attrs = ('microscope|MicroscopeWrapper',) 4412
4413 - def __bstrap__ (self):
4414 self.OMERO_CLASS = 'Instrument'
4415
4416 - def getMicroscope (self):
4417 if self._obj.microscope is not None: 4418 return MicroscopeWrapper(self._conn, self._obj.microscope) 4419 return None
4420
4421 - def getDetectors (self):
4422 return [DetectorWrapper(self._conn, x) for x in self._detectorSeq]
4423
4424 - def getObjectives (self):
4425 return [ObjectiveWrapper(self._conn, x) for x in self._objectiveSeq]
4426
4427 - def getFilters (self):
4428 return [FilterWrapper(self._conn, x) for x in self._filterSeq]
4429
4430 - def getDichroics (self):
4431 return [DichroicWrapper(self._conn, x) for x in self._dichroicSeq]
4432
4433 - def getFilterSets (self):
4434 return [FilterSetWrapper(self._conn, x) for x in self._filterSetSeq]
4435
4436 - def getOTFs (self):
4437 return [OTFWrapper(self._conn, x) for x in self._otfSeq]
4438
4439 - def getLightSources (self):
4440 return [LightSourceWrapper(self._conn, x) for x in self._lightSourceSeq]
4441 4442
4443 - def simpleMarshal (self):
4444 if self._obj: 4445 rv = super(_InstrumentWrapper, self).simpleMarshal(parents=False) 4446 rv['detectors'] = [x.simpleMarshal() for x in self.getDetectors()] 4447 rv['objectives'] = [x.simpleMarshal() for x in self.getObjectives()] 4448 rv['filters'] = [x.simpleMarshal() for x in self.getFilters()] 4449 rv['dichroics'] = [x.simpleMarshal() for x in self.getDichroics()] 4450 rv['filterSets'] = [x.simpleMarshal() for x in self.getFilterSets()] 4451 rv['otfs'] = [x.simpleMarshal() for x in self.getOTFs()] 4452 rv['lightsources'] = [x.simpleMarshal() for x in self.getLightSources()] 4453 else: 4454 rv = {} 4455 return rv
4456 4457 InstrumentWrapper = _InstrumentWrapper 4458