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 rstring, rint, rlong, rbool, rtime 
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 isOwned(self):
248 return (self._obj.details.owner.id.val == self._conn.getEventContext().userId)
249
250 - def isLeaded(self):
251 if self._obj.details.group.id.val in self._conn.getEventContext().leaderOfGroups: 252 return True 253 return False
254
255 - def isEditable(self):
256 if self.isOwned(): 257 return True 258 elif not self.isPrivate() and not self.isReadOnly(): 259 return True 260 return False
261
262 - def isPublic(self):
263 return self._obj.details.permissions.isWorldRead()
264
265 - def isShared(self):
266 if not self.isPublic(): 267 return self._obj.details.permissions.isGroupRead() 268 return False
269
270 - def isPrivate(self):
271 if not self.isPublic() and not self.isShared(): 272 return self._obj.details.permissions.isUserRead() 273 return False
274
275 - def isReadOnly(self):
276 if self.isPublic() and not self._obj.details.permissions.isWorldWrite(): 277 return True 278 elif self.isShared() and not self._obj.details.permissions.isGroupWrite(): 279 return True 280 elif self.isPrivate() and not self._obj.details.permissions.isUserWrite(): 281 return True 282 return False
283 284 #@timeit 285 #def getUID (self): 286 # p = self.listParents() 287 # return p and '%s:%s' % (p.getUID(), str(self.id)) or str(self.id) 288 289 #def getChild (self, oid): 290 # q = self._conn.getQueryService() 291 # ds = q.find(self.CHILD_WRAPPER_CLASS.OMERO_CLASS, long(oid)) 292 # if ds is not None: 293 # ds = self.CHILD_WRAPPER_CLASS(self._conn, ds) 294 # return ds 295
296 - def countChildren (self):
297 """ 298 Counts available number of child objects. 299 300 @return: Long. The number of child objects available 301 """ 302 303 childw = self._getChildWrapper() 304 klass = "%sLinks" % childw().OMERO_CLASS.lower() 305 #self._cached_countChildren = len(self._conn.getQueryService().findAllByQuery("from %s as c where c.parent.id=%i" % (self.LINK_CLASS, self._oid), None)) 306 self._cached_countChildren = self._conn.getContainerService().getCollectionCount(self.OMERO_CLASS, klass, [self._oid], None)[self._oid] 307 return self._cached_countChildren
308
309 - def countChildren_cached (self):
310 """ 311 countChildren, but caching the first result, useful if you need to call this multiple times in 312 a single sequence, but have no way of storing the value between them. 313 It is actually a hack to support django template's lack of break in for loops 314 315 @return: Long 316 """ 317 318 if not hasattr(self, '_cached_countChildren'): 319 return self.countChildren() 320 return self._cached_countChildren
321
322 - def listChildren (self, ns=None, val=None, params=None):
323 """ 324 Lists available child objects. 325 326 @return: Generator yielding child objects. 327 """ 328 329 childw = self._getChildWrapper() 330 klass = childw().OMERO_CLASS 331 # if getattr(self, 'is%sLinksLoaded' % klass)(): 332 # childns = getattr(self, 'copy%sLinks' % klass)() 333 # childnodes = [ x.child for x in childns] 334 # logger.debug('listChildren for %s %d: already loaded' % (self.OMERO_CLASS, self.getId())) 335 # else: 336 if not params: 337 params = omero.sys.Parameters() 338 if not params.map: 339 params.map = {} 340 params.map["dsid"] = omero_type(self._oid) 341 query = "select c from %s as c" % self.LINK_CLASS 342 if ns is not None: 343 params.map["ns"] = omero_type(ns) 344 #query += """ join c.child.annotationLinks ial 345 # join ial.child as a """ 346 query += """ join fetch c.child as ch 347 left outer join fetch ch.annotationLinks as ial 348 left outer join fetch ial.child as a """ 349 query += " where c.parent.id=:dsid" 350 if ns is not None: 351 query += " and a.ns=:ns" 352 if val is not None: 353 if isinstance(val, StringTypes): 354 params.map["val"] = omero_type(val) 355 query +=" and a.textValue=:val" 356 query += " order by c.child.name" 357 childnodes = [ x.child for x in self._conn.getQueryService().findAllByQuery(query, params)] 358 for child in childnodes: 359 yield childw(self._conn, child, self._cache)
360 361 #def listChildren_cached (self): 362 # """ This version caches all child nodes for all parents, so next parent does not need to search again. 363 # Good for full depth traversal, but a waste of time otherwise """ 364 # if self.CHILD_WRAPPER_CLASS is None: #pragma: no cover 365 # raise NotImplementedError 366 # if not self._cache.has_key(self.LINK_CLASS): 367 # pdl = {} 368 # for link in self._conn.getQueryService().findAll(self.LINK_CLASS, None): 369 # pid = link.parent.id.val 370 # if pdl.has_key(pid): 371 # pdl[pid].append(link.child) 372 # else: 373 # pdl[pid] = [link.child] 374 # self._cache[self.LINK_CLASS] = pdl 375 # for child in self._cache[self.LINK_CLASS].get(self._oid, ()): 376 # yield self.CHILD_WRAPPER_CLASS(self._conn, child, self._cache) 377
378 - def listParents (self, single=True, withlinks=False):
379 """ 380 Lists available parent objects. 381 382 @return: Generator yielding parent objects 383 """ 384 385 if self.PARENT_WRAPPER_CLASS is None: 386 if single: 387 return withlinks and (None, None) or None 388 return () 389 parentw = self._getParentWrapper() 390 param = omero.sys.Parameters() # TODO: What can I use this for? 391 if withlinks: 392 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)] 393 else: 394 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)] 395 if single: 396 return len(parentnodes) and parentnodes[0] or None 397 return parentnodes
398 399
400 - def getAncestry (self):
401 rv = [] 402 p = self.listParents() 403 while p: 404 rv.append(p) 405 p = p.listParents() 406 return rv
407 408 416 417 424 425
426 - def removeAnnotations (self, ns):
427 for al in self._getAnnotationLinks(ns=ns): 428 a = al.child 429 update = self._conn.getUpdateService() 430 update.deleteObject(al) 431 update.deleteObject(a) 432 self._obj.unloadAnnotationLinks()
433
434 - def getAnnotation (self, ns=None):
435 """ 436 ets the first annotation in the ns namespace, linked to this object 437 438 @return: #AnnotationWrapper or None 439 """ 440 rv = self._getAnnotationLinks(ns) 441 if len(rv): 442 return AnnotationWrapper._wrap(self._conn, rv[0].child) 443 return None
444
445 - def listAnnotations (self, ns=None):
446 """ 447 List annotations in the ns namespace, linked to this object 448 449 @return: Generator yielding AnnotationWrapper 450 """ 451 452 for ann in self._getAnnotationLinks(ns): 453 yield AnnotationWrapper._wrap(self._conn, ann.child, link=ann)
454 455
456 - def _linkAnnotation (self, ann):
457 if not ann.getId(): 458 # Not yet in db, save it 459 ann.details.setPermissions(omero.model.PermissionsI()) 460 ann.details.permissions.setWorldRead(True) 461 ann.details.permissions.setGroupWrite(True) 462 ann = ann.__class__(self._conn, self._conn.getUpdateService().saveAndReturnObject(ann._obj)) 463 #else: 464 # ann.save() 465 lnktype = "%sAnnotationLinkI" % self.OMERO_CLASS 466 lnk = getattr(omero.model, lnktype)() 467 lnk.details.setPermissions(omero.model.PermissionsI()) 468 lnk.details.permissions.setWorldRead(True) 469 lnk.details.permissions.setGroupWrite(True) 470 lnk.details.permissions.setUserWrite(True) 471 lnk.setParent(self._obj.__class__(self._obj.id, False)) 472 lnk.setChild(ann._obj.__class__(ann._obj.id, False)) 473 self._conn.getUpdateService().saveObject(lnk) 474 return ann
475 476
477 - def linkAnnotation (self, ann, sameOwner=True):
478 if sameOwner: 479 d = self.getDetails() 480 ad = ann.getDetails() 481 if self._conn.isAdmin() and self._conn._userid != d.getOwner().id: 482 # Keep the annotation owner the same as the linked of object's 483 if ad.getOwner() and d.getOwner().omeName == ad.getOwner().omeName and d.getGroup().name == ad.getGroup().name: 484 newConn = ann._conn 485 else: 486 #p = omero.sys.Principal() 487 #p.name = d.getOwner().omeName 488 group = None 489 if d.getGroup(): 490 group = d.getGroup().name 491 newConn = self._conn.suConn(d.getOwner().omeName, group) 492 #p.eventType = "User" 493 #newConnId = self._conn.getSessionService().createSessionWithTimeout(p, 60000) 494 #newConn = self._conn.clone() 495 #newConn.connect(sUuid=newConnId.getUuid().val) 496 clone = self.__class__(newConn, self._obj) 497 ann = clone._linkAnnotation(ann) 498 elif d.getGroup(): 499 # Try to match group 500 self._conn.setGroupForSession(d.getGroup().getId()) 501 ann = self._linkAnnotation(ann) 502 self._conn.revertGroupForSession() 503 else: 504 ann = self._linkAnnotation(ann) 505 else: 506 ann = self._linkAnnotation(ann) 507 self.unloadAnnotationLinks() 508 return ann
509 510
511 - def simpleMarshal (self, xtra=None, parents=False):
512 rv = {'type': self.OMERO_CLASS, 513 'id': self.getId(), 514 'name': self.getName(), 515 'description': self.getDescription(), 516 } 517 if hasattr(self, '_attrs'): 518 # 'key' -> key = _obj[key] 519 # '#key' -> key = _obj[key].value.val 520 # 'key;title' -> title = _obj[key] 521 # 'key|wrapper' -> key = omero.gateway.wrapper(_obj[key]).simpleMarshal 522 for k in self._attrs: 523 if ';' in k: 524 s = k.split(';') 525 k = s[0] 526 rk = ';'.join(s[1:]) 527 else: 528 rk = k 529 rk = rk.replace('#', '') 530 if '|' in k: 531 s = k.split('|') 532 k2 = s[0] 533 w = '|'.join(s[1:]) 534 if rk == k: 535 rk = k2 536 k = k2 537 538 v = getattr(self, k) 539 if v is not None: 540 v = getattr(omero.gateway, w)(self._conn, v).simpleMarshal() 541 else: 542 if k.startswith('#'): 543 v = getattr(self, k[1:]) 544 if v is not None: 545 v = v._value 546 else: 547 v = getattr(self, k) 548 if hasattr(v, 'val'): 549 v = v.val 550 rv[rk] = v 551 if xtra: # TODO check if this can be moved to a more specific place 552 if xtra.has_key('childCount'): 553 rv['child_count'] = self.countChildren() 554 if parents: 555 rv['parents'] = map(lambda x: x.simpleMarshal(), self.getAncestry()) 556 return rv
557 558 #def __str__ (self): 559 # if hasattr(self._obj, 'value'): 560 # return str(self.value) 561 # return str(self._obj) 562
563 - def __getattr__ (self, attr):
564 if attr != 'get' and attr.startswith('get') and hasattr(self, '_attrs'): 565 tattr = attr[3].lower() + attr[4:] 566 attrs = filter(lambda x: tattr in x, self._attrs) 567 for a in attrs: 568 if a.startswith('#') and a[1:] == tattr: 569 v = getattr(self, tattr) 570 if v is not None: 571 v = v._value 572 def wrap (): 573 return v
574 return wrap 575 if len(a) > len(tattr) and a[len(tattr)] == '|': 576 def wrap (): 577 return getattr(omero.gateway, a[len(tattr)+1:])(self._conn, getattr(self, tattr))
578 return wrap 579 if not hasattr(self._obj, attr) and hasattr(self._obj, '_'+attr): 580 attr = '_' + attr 581 if hasattr(self._obj, attr): 582 rv = getattr(self._obj, attr) 583 if hasattr(rv, 'val'): 584 return isinstance(rv.val, StringType) and rv.val.decode('utf8') or rv.val 585 return rv 586 raise AttributeError("'%s' object has no attribute '%s'" % (self._obj.__class__.__name__, attr)) 587 588 589 # some methods are accessors in _obj and return and omero:: type. The obvious ones we wrap to return a python type 590
591 - def getId (self):
592 """ 593 Gets this object ID 594 595 @return: Long or None 596 """ 597 oid = self._obj.getId() 598 if oid is not None: 599 return oid.val 600 return None
601
602 - def getName (self):
603 """ 604 Gets this object name 605 606 @return: String or None 607 """ 608 if hasattr(self._obj, 'name'): 609 if hasattr(self._obj.name, 'val'): 610 return self._obj.getName().val 611 else: 612 return self._obj.getName() 613 else: 614 return None
615
616 - def getDescription (self):
617 """ 618 Gets this object description 619 620 @return: String 621 """ 622 623 rv = hasattr(self._obj, 'description') and self._obj.getDescription() or None 624 return rv and rv.val or ''
625
626 - def getOwner (self):
627 """ 628 Gets user who is the owner of this object. 629 630 @return: _ExperimenterWrapper 631 """ 632 633 return self.getDetails().getOwner()
634
635 - def getOwnerFullName (self):
636 """ 637 Gets full name of the owner of this object. 638 639 @return: String or None 640 """ 641 642 try: 643 lastName = self.getDetails().getOwner().lastName 644 firstName = self.getDetails().getOwner().firstName 645 middleName = self.getDetails().getOwner().middleName 646 647 if middleName is not None and middleName != '': 648 name = "%s %s. %s" % (firstName, middleName, lastName) 649 else: 650 name = "%s %s" % (firstName, lastName) 651 return name 652 except: 653 logger.error(traceback.format_exc()) 654 return None
655
656 - def getOwnerOmeName (self):
657 """ 658 Gets omeName of the owner of this object. 659 660 @return: String 661 """ 662 return self.getDetails().getOwner().omeName
663
664 - def creationEventDate(self):
665 """ 666 Gets event time in timestamp format (yyyy-mm-dd hh:mm:ss.fffffff) when object was created. 667 668 @return: Long 669 """ 670 671 try: 672 if self._obj.details.creationEvent.time is not None: 673 t = self._obj.details.creationEvent.time.val 674 else: 675 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val 676 except: 677 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val 678 return datetime.fromtimestamp(t/1000)
679
680 - def updateEventDate(self):
681 """ 682 Gets event time in timestamp format (yyyy-mm-dd hh:mm:ss.fffffff) when object was updated. 683 684 @return: Long 685 """ 686 687 try: 688 if self._obj.details.updateEvent.time is not None: 689 t = self._obj.details.updateEvent.time.val 690 else: 691 t = self._conn.getQueryService().get("Event", self._obj.details.updateEvent.id.val).time.val 692 except: 693 t = self._conn.getQueryService().get("Event", self._obj.details.updateEvent.id.val).time.val 694 return datetime.fromtimestamp(t/1000)
695 696 697 # setters are also provided 698
699 - def setName (self, value):
700 self._obj.setName(omero_type(value))
701
702 - def setDescription (self, value):
703 self._obj.setDescription(omero_type(value))
704
705 ## BASIC ## 706 707 -class NoProxies (object):
708 - def __getitem__ (self, k):
709 raise Ice.ConnectionLostException
710
711 -class _BlitzGateway (object):
712 """ 713 ICE_CONFIG - Defines the path to the Ice configuration 714 """ 715 716 ICE_CONFIG = None#os.path.join(p,'etc/ice.config') 717 # def __init__ (self, username, passwd, server, port, client_obj=None, group=None, clone=False): 718
719 - 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):
720 """ 721 TODO: Constructor 722 723 @param username: User name. String 724 @param passwd: Password. String 725 @param client_obj: omero.client 726 @param group: admin group 727 @param clone: Boolean 728 @param try_super: Boolean 729 @param host: Omero server host. String 730 @param port: Omero server port. Integer 731 @param extra_config: 732 @param secure: Initial underlying omero.client connection type (True=SSL/False=insecure) 733 """ 734 735 super(_BlitzGateway, self).__init__() 736 self.client = client_obj 737 if not type(extra_config) in (type(()), type([])): 738 extra_config=[extra_config] 739 self.extra_config = extra_config 740 self.ice_config = [self.ICE_CONFIG] 741 self.ice_config.extend(extra_config) 742 self.ice_config = map(lambda x: str(x), filter(None, self.ice_config)) 743 744 self.host = host 745 self.port = port 746 self.secure = secure 747 748 self._resetOmeroClient() 749 if not username: 750 username = self.c.ic.getProperties().getProperty('omero.gateway.anon_user') 751 passwd = self.c.ic.getProperties().getProperty('omero.gateway.anon_pass') 752 #logger.debug('super: %s %s %s' % (try_super, str(group), self.c.ic.getProperties().getProperty('omero.gateway.admin_group'))) 753 if try_super: 754 self.group = 'system' #self.c.ic.getProperties().getProperty('omero.gateway.admin_group') 755 else: 756 self.group = group and group or None 757 self._sessionUuid = None 758 self._session_cb = None 759 self._session = None 760 self._lastGroupId = None 761 self._anonymous = True 762 763 # The properties we are setting through the interface 764 self.setIdentity(username, passwd, not clone) 765 766 self._connected = False 767 self._user = None 768 self._userid = None 769 self._proxies = NoProxies()
770
771 - def getProperty(self, k):
772 return self.c.getProperty(k)
773
774 - def clone (self):
775 return self.__class__(self._ic_props[omero.constants.USERNAME], 776 self._ic_props[omero.constants.PASSWORD], 777 host = self.host, 778 port = self.port, 779 extra_config=self.extra_config, 780 clone=True, 781 secure=self.secure)
782 #self.server, self.port, clone=True) 783
784 - def setIdentity (self, username, passwd, _internal=False):
785 """ 786 TODO: description 787 788 @param username: User name. String 789 @param passwd: Password. String 790 @param _internal: Boolean 791 """ 792 793 self._ic_props = {omero.constants.USERNAME: username, 794 omero.constants.PASSWORD: passwd} 795 self._anonymous = _internal
796
797 - def suConn (self, username, group=None, ttl=60000):
798 """ If current user isAdmin, return new connection owned by 'username' """ 799 if self.isAdmin(): 800 if group is None: 801 e = self.lookupExperimenter(username) 802 if e is None: 803 return 804 group = e._obj._groupExperimenterMapSeq[0].parent.name.val 805 p = omero.sys.Principal() 806 p.name = username 807 p.group = group 808 p.eventType = "User" 809 newConnId = self.getSessionService().createSessionWithTimeout(p, ttl) 810 newConn = self.clone() 811 newConn.connect(sUuid=newConnId.getUuid().val) 812 return newConn
813
814 - def keepAlive (self):
815 """ 816 Keeps service alive. 817 Returns True if connected. If connection was lost, reconnecting. 818 819 @return: Boolean 820 """ 821 822 try: 823 if self.c.sf is None: #pragma: no cover 824 logger.debug('... c.sf is None, reconnecting') 825 return self.connect() 826 return self.c.sf.keepAlive(self._proxies['admin']._obj) 827 except Ice.ObjectNotExistException: #pragma: no cover 828 # The connection is there, but it has been reset, because the proxy no longer exists... 829 logger.debug(traceback.format_exc()) 830 logger.debug("... reset, not reconnecting") 831 return False 832 except Ice.ConnectionLostException: #pragma: no cover 833 # The connection was lost. This shouldn't happen, as we keep pinging it, but does so... 834 logger.debug(traceback.format_exc()) 835 logger.debug("... lost, reconnecting") 836 return self.connect() 837 except Ice.ConnectionRefusedException: #pragma: no cover 838 # The connection was refused. We lost contact with glacier2router... 839 logger.debug(traceback.format_exc()) 840 logger.debug("... refused, not reconnecting") 841 return False 842 except omero.SessionTimeoutException: #pragma: no cover 843 # The connection is there, but it has been reset, because the proxy no longer exists... 844 logger.debug(traceback.format_exc()) 845 logger.debug("... reset, not reconnecting") 846 return False 847 except omero.RemovedSessionException: #pragma: no cover 848 # Session died on us 849 logger.debug(traceback.format_exc()) 850 logger.debug("... session has left the building, not reconnecting") 851 return False 852 except Ice.UnknownException, x: #pragma: no cover 853 # Probably a wrapped RemovedSession 854 logger.debug(traceback.format_exc()) 855 logger.debug('Ice.UnknownException: %s' % str(x)) 856 logger.debug("... ice says something bad happened, not reconnecting") 857 return False 858 except: 859 # Something else happened 860 logger.debug(traceback.format_exc()) 861 logger.debug("... error not reconnecting") 862 return False
863
864 - def seppuku (self, softclose=False): #pragma: no cover
865 """ 866 Terminates connection. If softclose is False, the session is really 867 terminate disregarding its connection refcount. 868 869 @param softclose: Boolean 870 """ 871 872 self._connected = False 873 if self.c: 874 try: 875 self.c.sf.closeOnDestroy() 876 except Ice.ConnectionLostException: 877 pass 878 except Glacier2.SessionNotExistException: 879 pass 880 except AttributeError: 881 pass 882 try: 883 if softclose: 884 try: 885 r = self.c.sf.getSessionService().getReferenceCount(self._sessionUuid) 886 self.c.closeSession() 887 if r < 2: 888 self._session_cb and self._session_cb.close(self) 889 except Ice.OperationNotExistException: 890 self.c.closeSession() 891 else: 892 self._closeSession() 893 except Glacier2.SessionNotExistException: 894 pass 895 except Ice.ConnectionLostException: 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['script'] = ProxyObjectWrapper(self, 'getScriptService') 932 self._proxies['search'] = ProxyObjectWrapper(self, 'createSearchService') 933 self._proxies['session'] = ProxyObjectWrapper(self, 'getSessionService') 934 self._proxies['share'] = ProxyObjectWrapper(self, 'getShareService') 935 self._proxies['thumbs'] = ProxyObjectWrapper(self, 'createThumbnailStore') 936 self._proxies['timeline'] = ProxyObjectWrapper(self, 'getTimelineService') 937 self._proxies['types'] = ProxyObjectWrapper(self, 'getTypesService') 938 self._proxies['update'] = ProxyObjectWrapper(self, 'getUpdateService') 939 940 self._ctx = self._proxies['admin'].getEventContext() 941 self._userid = self._ctx.userId 942 self._user = self.getExperimenter(self._userid) 943 if self._session_cb: #pragma: no cover 944 if self._was_join: 945 self._session_cb.join(self) 946 else: 947 self._session_cb.create(self)
948
949 - def setSecure (self, secure=True):
950 """ Switches between SSL and insecure (faster) connections to Blitz. 951 The gateway must already be connected. """ 952 if hasattr(self.c, 'createClient') and (secure ^ self.c.isSecure()): 953 self.c = self.c.createClient(secure=secure) 954 self._createProxies() 955 self.secure = secure
956
957 - def isSecure (self):
958 """ Returns 'True' if the underlying omero.clients.BaseClient is connected using SSL """ 959 return hasattr(self.c, 'isSecure') and self.c.isSecure() or False
960
961 - def _createSession (self, skipSUuid=False):
962 """ 963 Creates a new session for the principal given in the constructor. 964 """ 965 s = self.c.createSession(self._ic_props[omero.constants.USERNAME], 966 self._ic_props[omero.constants.PASSWORD]) 967 self._sessionUuid = self.c.sf.ice_getIdentity().name 968 ss = self.c.sf.getSessionService() 969 self._session = ss.getSession(self._sessionUuid) 970 self._lastGroupId = None 971 s.detachOnDestroy() 972 self._was_join = False 973 if self.group is not None: 974 # try something that fails if the user don't have permissions on the group 975 self.c.sf.getAdminService().getEventContext() 976 self.setSecure(self.secure)
977
978 - def _closeSession (self):
979 """ 980 Close session. 981 """ 982 983 self._session_cb and self._session_cb.close(self) 984 if self._sessionUuid: 985 s = omero.model.SessionI() 986 s._uuid = omero_type(self._sessionUuid) 987 try: 988 r = 1 989 while r: 990 r = self.c.sf.getSessionService().closeSession(s) 991 except Ice.ObjectNotExistException: 992 pass 993 except omero.RemovedSessionException: 994 pass 995 except ValueError: 996 raise 997 except: #pragma: no cover 998 logger.warn(traceback.format_exc()) 999 try: 1000 self.c.closeSession() 1001 except Glacier2.SessionNotExistException: #pragma: no cover 1002 pass
1003
1004 - def _resetOmeroClient (self):
1005 """ 1006 Resets omero.client object. 1007 """ 1008 1009 if self.host is not None: 1010 self.c = omero.client(host=str(self.host), port=int(self.port))#, pmap=['--Ice.Config='+','.join(self.ice_config)]) 1011 else: 1012 self.c = omero.client(pmap=['--Ice.Config='+','.join(self.ice_config)]) 1013 1014 if hasattr(self.c, "setAgent"): 1015 self.c.setAgent("OMERO.py.gateway")
1016
1017 - def connect (self, sUuid=None):
1018 """ 1019 Creates or retrieves connection for the given sessionUuid. 1020 Returns True if connected. 1021 1022 @param sUuid: omero_model_SessionI 1023 @return: Boolean 1024 """ 1025 1026 logger.debug("Connect attempt, sUuid=%s, group=%s, self.sUuid=%s" % (str(sUuid), str(self.group), self._sessionUuid)) 1027 if not self.c: #pragma: no cover 1028 self._connected = False 1029 logger.debug("Ooops. no self._c") 1030 return False 1031 try: 1032 if self._sessionUuid is None and sUuid: 1033 self._sessionUuid = sUuid 1034 if self._sessionUuid is not None: 1035 try: 1036 logger.debug('connected? %s' % str(self._connected)) 1037 if self._connected: 1038 self._connected = False 1039 logger.debug("was connected, creating new omero.client") 1040 self._resetOmeroClient() 1041 s = self.c.joinSession(self._sessionUuid) 1042 s.detachOnDestroy() 1043 logger.debug('joinSession(%s)' % self._sessionUuid) 1044 self._was_join = True 1045 except Ice.SyscallException: #pragma: no cover 1046 raise 1047 except Exception, x: #pragma: no cover 1048 logger.debug("Error: " + str(x)) 1049 self._sessionUuid = None 1050 if sUuid: 1051 return False 1052 if self._sessionUuid is None: 1053 if sUuid: #pragma: no cover 1054 logger.debug("Uncaptured sUuid failure!") 1055 if self._connected: 1056 self._connected = False 1057 try: 1058 #args = self.c._ic_args 1059 #logger.debug(str(args)) 1060 self._closeSession() 1061 self._resetOmeroClient() 1062 #self.c = omero.client(*args) 1063 except Glacier2.SessionNotExistException: #pragma: no cover 1064 pass 1065 setprop = self.c.ic.getProperties().setProperty 1066 map(lambda x: setprop(x[0],str(x[1])), self._ic_props.items()) 1067 if self._anonymous: 1068 self.c.ic.getImplicitContext().put(omero.constants.EVENT, 'Internal') 1069 if self.group is not None: 1070 self.c.ic.getImplicitContext().put(omero.constants.GROUP, self.group) 1071 try: 1072 self._createSession() 1073 except omero.SecurityViolation: 1074 if self.group is not None: 1075 # User don't have access to group 1076 logger.debug("## User not in '%s' group" % self.group) 1077 self.group = None 1078 self._closeSession() 1079 self._sessionUuid = None 1080 self._connected=True 1081 return self.connect() 1082 else: #pragma: no cover 1083 logger.debug("BlitzGateway.connect().createSession(): " + traceback.format_exc()) 1084 logger.info('first create session threw SecurityViolation, hold off 10 secs and retry (but only once)') 1085 #time.sleep(10) 1086 try: 1087 self._createSession() 1088 except omero.SecurityViolation: 1089 if self.group is not None: 1090 # User don't have access to group 1091 logger.debug("## User not in '%s' group" % self.group) 1092 self.group = None 1093 self._connected=True 1094 return self.connect() 1095 else: 1096 raise 1097 except Ice.SyscallException: #pragma: no cover 1098 raise 1099 except: 1100 logger.info("BlitzGateway.connect().createSession(): " + traceback.format_exc()) 1101 logger.debug(str(self._ic_props)) 1102 #time.sleep(10) 1103 self._createSession() 1104 1105 self._last_error = None 1106 self._createProxies() 1107 self._connected = True 1108 logger.info('created connection (uuid=%s)' % str(self._sessionUuid)) 1109 except Ice.SyscallException: #pragma: no cover 1110 logger.debug('This one is a SyscallException') 1111 raise 1112 except Ice.LocalException, x: #pragma: no cover 1113 logger.debug("connect(): " + traceback.format_exc()) 1114 self._last_error = x 1115 return False 1116 except Exception, x: #pragma: no cover 1117 logger.debug("connect(): " + traceback.format_exc()) 1118 self._last_error = x 1119 return False 1120 logger.debug(".. connected!") 1121 return True
1122
1123 - def getLastError (self): #pragma: no cover
1124 """ 1125 Returns error if thrown by _BlitzGateway.connect connect. 1126 1127 @return: String 1128 """ 1129 1130 return self._last_error 1131
1132 - def isConnected (self):
1133 """ 1134 Returns last status of connection. 1135 1136 @return: Boolean 1137 """ 1138 1139 return self._connected
1140 1141 ###################### 1142 ## Connection Stuff ## 1143
1144 - def getEventContext (self):
1145 """ 1146 Returns omero_System_ice.EventContext. 1147 It containes:: 1148 shareId, sessionId, sessionUuid, userId, userName, 1149 groupId, groupName, isAdmin, isReadOnly, 1150 eventId, eventType, eventType, 1151 memberOfGroups, leaderOfGroups 1152 1153 @return: omero.sys.EventContext 1154 """ 1155 1156 self._ctx = self._proxies['admin'].getEventContext() 1157 return self._ctx
1158
1159 - def getUser (self):
1160 """ 1161 Returns current omero_model_ExperimenterI. 1162 1163 @return: omero.model.ExperimenterI 1164 """ 1165 1166 return self._user
1167
1168 - def isAdmin (self):
1169 """ 1170 Checks if a user has administration privileges. 1171 1172 @return: Boolean 1173 """ 1174 1175 return self.getEventContext().isAdmin
1176
1177 - def canBeAdmin (self):
1178 """ 1179 Checks if a user is in system group, i.e. can have administration privileges. 1180 1181 @return: Boolean 1182 """ 1183 return 0 in self.getEventContext().memberOfGroups
1184
1185 - def isOwner (self, gid=None):
1186 """ 1187 Checks if a user has owner privileges. 1188 1189 @return: Boolean 1190 """ 1191 if not isinstance(gid, LongType) or not isinstance(gid, IntType): 1192 gid = long(gid) 1193 if gid is not None: 1194 for gem in self._user.copyGroupExperimenterMap(): 1195 if gem.parent.id.val == gid and gem.owner.val == True: 1196 return True 1197 else: 1198 for gem in self._user.copyGroupExperimenterMap(): 1199 if gem.owner.val == True: 1200 return True 1201 return False
1202
1203 - def canWrite (self, obj):
1204 """ 1205 Checks if a user has write privileges to the given object. 1206 1207 @param obj: Given object 1208 @return: Boolean 1209 """ 1210 1211 return self.isAdmin() or (self._userid == obj.details.owner.id.val and obj.details.permissions.isUserWrite())
1212
1213 - def getSession (self):
1214 if self._session is None: 1215 ss = self.c.sf.getSessionService() 1216 self._session = ss.getSession(self._sessionUuid) 1217 return self._session
1218 1219 # def setDefaultPermissionsForSession (self, permissions): 1220 # self.getSession() 1221 # self._session.setDefaultPermissions(rstring(permissions)) 1222 # self._session.setTimeToIdle(None) 1223 # self.getSessionService().updateSession(self._session) 1224
1225 - def setGroupNameForSession (self, group):
1226 a = self.getAdminService() 1227 g = a.lookupGroup(group) 1228 return self.setGroupForSession(g.getId().val)
1229
1230 - def setGroupForSession (self, groupid):
1231 if self.getEventContext().groupId == groupid: 1232 return True 1233 if groupid not in self._ctx.memberOfGroups: 1234 return False 1235 self._lastGroupId = self._ctx.groupId 1236 if hasattr(self.c, 'setSecurityContext'): 1237 # Beta4.2 1238 self.c.sf.setSecurityContext(omero.model.ExperimenterGroupI(groupid, False)) 1239 else: 1240 self.getSession() 1241 self._session.getDetails().setGroup(omero.model.ExperimenterGroupI(groupid, False)) 1242 self._session.setTimeToIdle(None) 1243 self.getSessionService().updateSession(self._session) 1244 return True
1245 1246 1247 # def setGroupForSession (self, group): 1248 # self.getSession() 1249 # if self._session.getDetails().getGroup().getId().val == group.getId(): 1250 # # Already correct 1251 # return 1252 # a = self.getAdminService() 1253 # if not group.name in [x.name.val for x in a.containedGroups(self._userid)]: 1254 # # User not in this group 1255 # return 1256 # self._lastGroup = self._session.getDetails().getGroup() 1257 # self._session.getDetails().setGroup(group._obj) 1258 # self._session.setTimeToIdle(None) 1259 # self.getSessionService().updateSession(self._session) 1260 #
1261 - def revertGroupForSession (self):
1262 if self._lastGroupId is not None: 1263 self.setGroupForSession(self._lastGroupId) 1264 self._lastGroupId = None
1265 1266 ############## 1267 ## Services ## 1268
1269 - def getAdminService (self):
1270 """ 1271 Gets reference to the admin service from ProxyObjectWrapper. 1272 1273 @return: omero.gateway.ProxyObjectWrapper 1274 """ 1275 1276 return self._proxies['admin']
1277
1278 - def getQueryService (self):
1279 """ 1280 Gets reference to the query service from ProxyObjectWrapper. 1281 1282 @return: omero.gateway.ProxyObjectWrapper 1283 """ 1284 return self._proxies['query']
1285
1286 - def getContainerService (self):
1287 """ 1288 Gets reference to the container service from ProxyObjectWrapper. 1289 1290 @return: omero.gateway.ProxyObjectWrapper 1291 """ 1292 1293 return self._proxies['container']
1294
1295 - def getPixelsService (self):
1296 """ 1297 Gets reference to the pixels service from ProxyObjectWrapper. 1298 1299 @return: omero.gateway.ProxyObjectWrapper 1300 """ 1301 1302 return self._proxies['pixel']
1303
1304 - def getMetadataService (self):
1305 """ 1306 Gets reference to the metadata service from ProxyObjectWrapper. 1307 1308 @return: omero.gateway.ProxyObjectWrapper 1309 """ 1310 1311 return self._proxies['metadata']
1312
1313 - def createRawFileStore (self):
1314 """ 1315 Creates a new raw file store. 1316 This service is special in that it does not get cached inside BlitzGateway so every call to this function 1317 returns a new object, avoiding unexpected inherited states. 1318 1319 @return: omero.gateway.ProxyObjectWrapper 1320 """ 1321 1322 return self._proxies['rawfile']
1323
1324 - def getRepositoryInfoService (self):
1325 """ 1326 Gets reference to the repository info service from ProxyObjectWrapper. 1327 1328 @return: omero.gateway.ProxyObjectWrapper 1329 """ 1330 1331 return self._proxies['repository']
1332
1333 - def getShareService(self):
1334 """ 1335 Gets reference to the share service from ProxyObjectWrapper. 1336 1337 @return: omero.gateway.ProxyObjectWrapper 1338 """ 1339 1340 return self._proxies['share']
1341
1342 - def getTimelineService (self):
1343 """ 1344 Gets reference to the timeline service from ProxyObjectWrapper. 1345 1346 @return: omero.gateway.ProxyObjectWrapper 1347 """ 1348 1349 return self._proxies['timeline']
1350
1351 - def getTypesService(self):
1352 """ 1353 Gets reference to the types service from ProxyObjectWrapper. 1354 1355 @return: omero.gateway.ProxyObjectWrapper 1356 """ 1357 1358 return self._proxies['types']
1359
1360 - def getConfigService (self):
1361 """ 1362 Gets reference to the config service from ProxyObjectWrapper. 1363 1364 @return: omero.gateway.ProxyObjectWrapper 1365 """ 1366 1367 return self._proxies['config']
1368
1369 - def createRenderingEngine (self):
1370 """ 1371 Creates a new rendering engine. 1372 This service is special in that it does not get cached inside BlitzGateway so every call to this function 1373 returns a new object, avoiding unexpected inherited states. 1374 1375 @return: omero.gateway.ProxyObjectWrapper 1376 """ 1377 1378 rv = self._proxies['rendering'] 1379 if rv._tainted: 1380 rv = self._proxies['rendering'] = rv.clone() 1381 rv.taint() 1382 return rv
1383
1384 - def getRenderingSettingsService (self):
1385 """ 1386 Gets reference to the rendering settings service from ProxyObjectWrapper. 1387 1388 @return: omero.gateway.ProxyObjectWrapper 1389 """ 1390 1391 return self._proxies['rendsettings']
1392
1393 - def createRawPixelsStore (self):
1394 """ 1395 Creates a new raw pixels store. 1396 This service is special in that it does not get cached inside BlitzGateway so every call to this function 1397 returns a new object, avoiding unexpected inherited states. 1398 1399 @return: omero.gateway.ProxyObjectWrapper 1400 """ 1401 1402 return self._proxies['rawpixels']
1403
1404 - def createThumbnailStore (self):
1405 """ 1406 Gets a reference to the thumbnail store on this connection object or creates a new one 1407 if none exists. 1408 1409 @rtype: omero.gateway.ProxyObjectWrapper 1410 @return: The proxy wrapper of the thumbnail store 1411 """ 1412 1413 return self._proxies['thumbs']
1414
1415 - def createSearchService (self):
1416 """ 1417 Creates a new search service. 1418 This service is special in that it does not get cached inside BlitzGateway so every call to this function 1419 returns a new object, avoiding unexpected inherited states. 1420 1421 @return: omero.gateway.ProxyObjectWrapper 1422 """ 1423 return self._proxies['search']
1424
1425 - def getUpdateService (self):
1426 """ 1427 Gets reference to the update service from ProxyObjectWrapper. 1428 1429 @return: omero.gateway.ProxyObjectWrapper 1430 """ 1431 return self._proxies['update']
1432
1433 - def getDeleteService (self):
1434 """ 1435 Gets reference to the delete service from ProxyObjectWrapper. 1436 1437 @return: omero.gateway.ProxyObjectWrapper 1438 """ 1439 return self._proxies['delete']
1440
1441 - def getSessionService (self):
1442 """ 1443 Gets reference to the session service from ProxyObjectWrapper. 1444 1445 @return: omero.gateway.ProxyObjectWrapper 1446 """ 1447 return self._proxies['session']
1448
1449 - def createExporter (self):
1450 """ 1451 New instance of non cached Exporter, wrapped in ProxyObjectWrapper. 1452 1453 @return: omero.gateway.ProxyObjectWrapper 1454 """ 1455 1456 return self._proxies['export']
1457 1458 ############################# 1459 # Top level object fetchers # 1460
1461 - def listProjects (self, only_owned=False):
1462 """ 1463 List every Projects controlled by the security system. 1464 1465 @param only_owned: Only owned by the logged user. Boolean. 1466 @return: Generator yielding _ProjectWrapper 1467 """ 1468 1469 q = self.getQueryService() 1470 cache = {} 1471 if only_owned: 1472 params = omero.sys.Parameters() 1473 params.map = {'owner_id': rlong(self._userid)} 1474 for e in q.findAllByQuery("from Project as p where p.details.owner.id=:owner_id order by p.name", params): 1475 yield ProjectWrapper(self, e, cache) 1476 else: 1477 for e in q.findAll('Project', None): 1478 yield ProjectWrapper(self, e, cache)
1479 1480 # def listCategoryGroups (self): 1481 # q = self.getQueryService() 1482 # cache = {} 1483 # for e in q.findAll("CategoryGroup", None): 1484 # yield CategoryGroupWrapper(self, e, cache) 1485
1486 - def listExperimenters (self, start=''):
1487 """ 1488 Return a generator for all Experimenters whose omeName starts with 'start'. 1489 The generated values follow the alphabetic order on omeName. 1490 1491 @param start: Only if omero_model_ExperimenterI.omeName starts with. String. 1492 @return: Generator yielding _ExperimenterWrapper 1493 """ 1494 1495 if isinstance(start, UnicodeType): 1496 start = start.encode('utf8') 1497 params = omero.sys.Parameters() 1498 params.map = {'start': rstring('%s%%' % start.lower())} 1499 q = self.getQueryService() 1500 rv = q.findAllByQuery("from Experimenter e where lower(e.omeName) like :start", params) 1501 rv.sort(lambda x,y: cmp(x.omeName.val,y.omeName.val)) 1502 for e in rv: 1503 yield ExperimenterWrapper(self, e)
1504
1505 - def getExperimenter(self, eid):
1506 """ 1507 Return an Experimenter for the given ID. 1508 1509 @param eid: User ID. 1510 @return: _ExperimenterWrapper or None 1511 """ 1512 1513 admin_serv = self.getAdminService() 1514 try: 1515 exp = admin_serv.getExperimenter(long(eid)) 1516 return ExperimenterWrapper(self, exp) 1517 except omero.ApiUsageException: 1518 return None
1519
1520 - def lookupExperimenter(self, name):
1521 """ 1522 Return an Experimenter for the given username. 1523 1524 @param name: Username. String 1525 @return: _ExperimenterWrapper or None 1526 """ 1527 1528 admin_serv = self.getAdminService() 1529 try: 1530 exp = admin_serv.lookupExperimenter(str(name)) 1531 return ExperimenterWrapper(self, exp) 1532 except omero.ApiUsageException: 1533 return None
1534 1535 ############################ 1536 # Timeline service getters # 1537
1538 - def timelineListImages (self, tfrom=None, tto=None, limit=10, only_owned=True):
1539 """ 1540 List images based on the their creation times. 1541 If both tfrom and tto are None, grab the most recent batch. 1542 1543 @param tfrom: milliseconds since the epoch for start date 1544 @param tto: milliseconds since the epoch for end date 1545 @param tlimit: maximum number of results 1546 @param only_owned: Only owned by the logged user. Boolean. 1547 @return: Generator yielding _ImageWrapper 1548 """ 1549 tm = self.getTimelineService() 1550 p = omero.sys.Parameters() 1551 f = omero.sys.Filter() 1552 if only_owned: 1553 f.ownerId = rlong(self.getEventContext().userId) 1554 f.groupId = rlong(self.getEventContext().groupId) 1555 else: 1556 f.ownerId = rlong(-1) 1557 f.groupId = None 1558 f.limit = rint(limit) 1559 p.theFilter = f 1560 if tfrom is None and tto is None: 1561 for e in tm.getMostRecentObjects(['Image'], p, False)["Image"]: 1562 yield ImageWrapper(self, e) 1563 else: 1564 if tfrom is None: 1565 tfrom = 0 1566 if tto is None: 1567 tto = time.time() * 1000 1568 for e in tm.getByPeriod(['Image'], rtime(long(tfrom)), rtime(long(tto)), p, False)['Image']: 1569 yield ImageWrapper(self, e)
1570 1571 1572 1573 1574 ########################### 1575 # Specific Object Getters # 1576
1577 - def getProject (self, oid):
1578 """ 1579 Return Project for the given ID. 1580 1581 @param oid: Project ID. 1582 @return: _ProjectWrapper or None 1583 """ 1584 1585 q = self.getQueryService() 1586 pr = q.find("Project", long(oid)) 1587 if pr is not None: 1588 pr = ProjectWrapper(self, pr) 1589 return pr
1590
1591 - def findProject (self, name):
1592 """ 1593 Return Project with the given name. 1594 1595 @param name: Project name. 1596 @return: _ProjectWrapper or None 1597 """ 1598 q = self.getQueryService() 1599 params = omero.sys.Parameters() 1600 if not params.map: 1601 params.map = {} 1602 params.map['name'] = rstring(name) 1603 pr = q.findAllByQuery("from Project as p where p.name=:name", params) 1604 if len(pr): 1605 return ProjectWrapper(self, pr[0]) 1606 return None
1607
1608 - def getDataset (self, oid):
1609 """ 1610 Return Dataset for the given ID. 1611 1612 @param oid: Dataset ID. 1613 @return: _DatasetWrapper or None 1614 """ 1615 1616 q = self.getQueryService() 1617 ds = q.find("Dataset", long(oid)) 1618 if ds is not None: 1619 ds = DatasetWrapper(self, ds) 1620 return ds
1621
1622 - def getImage (self, oid):
1623 """ 1624 Return Image for the given ID. 1625 1626 @param oid: Image ID. 1627 @return: _ImageWrapper or None 1628 """ 1629 1630 q = self.getQueryService() 1631 img = q.find("Image", long(oid)) 1632 if img is not None: 1633 img = ImageWrapper(self, img) 1634 return img
1635 1636 ############################## 1637 # Annotation based iterators # 1638
1639 - def listImages (self, ns, params=None):
1640 """ 1641 TODO: description 1642 1643 @return: Generator yielding _ImageWrapper 1644 """ 1645 1646 if not params: 1647 params = omero.sys.Parameters() 1648 if not params.map: 1649 params.map = {} 1650 params.map["ns"] = omero_type(ns) 1651 query = """ 1652 select i 1653 from Image i 1654 join i.annotationLinks ial 1655 join ial.child as a 1656 where a.ns = :ns 1657 order by a.id desc """ 1658 for i in self.getQueryService().findAllByQuery(query, params): 1659 yield ImageWrapper(self, i)
1660 1661 1662 ################ 1663 # Enumerations # 1664
1665 - def getEnumerationEntries(self, klass):
1666 types = self.getTypesService() 1667 for e in types.allEnumerations(str(klass)): 1668 yield EnumerationWrapper(self, e)
1669
1670 - def getEnumeration(self, klass, string):
1671 types = self.getTypesService() 1672 obj = types.getEnumeration(str(klass), str(string)) 1673 if obj is not None: 1674 return EnumerationWrapper(self, obj) 1675 else: 1676 return None
1677
1678 - def getEnumerationById(self, klass, eid):
1679 query_serv = self.getQueryService() 1680 obj = query_serv.find(klass, long(eid)) 1681 if obj is not None: 1682 return EnumerationWrapper(self, obj) 1683 else: 1684 return None
1685
1686 - def getOriginalEnumerations(self):
1687 types = self.getTypesService() 1688 rv = dict() 1689 for e in types.getOriginalEnumerations(): 1690 if rv.get(e.__class__.__name__) is None: 1691 rv[e.__class__.__name__] = list() 1692 rv[e.__class__.__name__].append(EnumerationWrapper(self, e)) 1693 return rv
1694
1695 - def getEnumerations(self):
1696 types = self.getTypesService() 1697 return types.getEnumerationTypes()
1698
1699 - def getEnumerationsWithEntries(self):
1700 types = self.getTypesService() 1701 rv = dict() 1702 for key, value in types.getEnumerationsWithEntries().items(): 1703 r = list() 1704 for e in value: 1705 r.append(EnumerationWrapper(self, e)) 1706 rv[key+"I"] = r 1707 return rv
1708
1709 - def deleteEnumeration(self, obj):
1710 types = self.getTypesService() 1711 types.deleteEnumeration(obj)
1712
1713 - def createEnumeration(self, obj):
1714 types = self.getTypesService() 1715 types.createEnumeration(obj)
1716
1717 - def resetEnumerations(self, klass):
1718 types = self.getTypesService() 1719 types.resetEnumerations(klass)
1720
1721 - def updateEnumerations(self, new_entries):
1722 types = self.getTypesService() 1723 types.updateEnumerations(new_entries)
1724 1725 1726 ################### 1727 # Searching stuff # 1728 1729
1730 - def searchImages (self, text):
1731 """ 1732 Fulltext search for images 1733 """ 1734 return self.simpleSearch(text,(ImageWrapper,))
1735 1736
1737 - def simpleSearch (self, text, types=None):
1738 """ 1739 Fulltext search on Projects, Datasets and Images. 1740 TODO: search other object types? 1741 TODO: batch support. 1742 """ 1743 if not text: 1744 return [] 1745 if isinstance(text, UnicodeType): 1746 text = text.encode('utf8') 1747 if types is None: 1748 types = (ProjectWrapper, DatasetWrapper, ImageWrapper) 1749 search = self.createSearchService() 1750 if text[0] in ('?','*'): 1751 search.setAllowLeadingWildcard(True) 1752 rv = [] 1753 for t in types: 1754 def actualSearch (): 1755 search.onlyType(t().OMERO_CLASS) 1756 search.byFullText(text)
1757 timeit(actualSearch)() 1758 if search.hasNext(): 1759 def searchProcessing (): 1760 rv.extend(map(lambda x: t(self, x), search.results())) 1761 timeit(searchProcessing)() 1762 search.close() 1763 return rv 1764
1765 -def safeCallWrap (self, attr, f): #pragma: no cover
1766 """ 1767 Captures called function. Throws an exception. 1768 1769 @return: 1770 """ 1771 1772 def inner (*args, **kwargs): 1773 try: 1774 return f(*args, **kwargs) 1775 except omero.ResourceError: 1776 logger.debug('captured resource error') 1777 raise 1778 except omero.SecurityViolation: 1779 raise 1780 except omero.ApiUsageException: 1781 raise 1782 except Ice.MemoryLimitException: 1783 raise 1784 except omero.InternalException: 1785 raise 1786 except Ice.Exception, x: 1787 # Failed 1788 logger.debug( "Ice.Exception (1) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs))) 1789 logger.debug(traceback.format_exc()) 1790 # Recreate the proxy object 1791 try: 1792 self._obj = self._create_func() 1793 func = getattr(self._obj, attr) 1794 return func(*args, **kwargs) 1795 except Ice.MemoryLimitException: 1796 raise 1797 except Ice.Exception, x: 1798 # Still Failed 1799 logger.debug("Ice.Exception (2) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs))) 1800 logger.debug(traceback.format_exc()) 1801 try: 1802 # Recreate connection 1803 self._connect() 1804 logger.debug('last try for %s' % attr) 1805 # Last try, don't catch exception 1806 func = getattr(self._obj, attr) 1807 return func(*args, **kwargs) 1808 except: 1809 raise 1810 1811 def wrapped (*args, **kwargs): #pragma: no cover 1812 try: 1813 return inner(*args, **kwargs) 1814 except Ice.MemoryLimitException: 1815 logger.debug("MemoryLimitException! abort, abort...") 1816 raise 1817 except omero.SecurityViolation: 1818 logger.debug("SecurityViolation, bailing out") 1819 raise 1820 except omero.ApiUsageException: 1821 logger.debug("ApiUsageException, bailing out") 1822 raise 1823 except Ice.UnknownException: 1824 logger.debug("UnknownException, bailing out") 1825 raise 1826 except Ice.Exception, x: 1827 logger.debug('wrapped ' + f.func_name) 1828 logger.debug(x.__dict__) 1829 if x.serverExceptionClass == 'ome.conditions.InternalException': 1830 if x.message.find('java.lang.NullPointerException') > 0: 1831 logger.debug("NullPointerException, bailing out") 1832 raise 1833 elif x.message.find('Session is dirty') >= 0: 1834 logger.debug("Session is dirty, bailing out") 1835 raise 1836 else: 1837 logger.debug(x.message) 1838 logger.debug("exception caught, first time we back off for 10 secs") 1839 logger.debug(traceback.format_exc()) 1840 #time.sleep(10) 1841 return inner(*args, **kwargs) 1842 return wrapped 1843 1844 1845 BlitzGateway = _BlitzGateway
1846 1847 1848 -def splitHTMLColor (color):
1849 """ splits an hex stream of characters into an array of bytes in format (R,G,B,A). 1850 - abc -> (0xAA, 0xBB, 0xCC, 0xFF) 1851 - abcd -> (0xAA, 0xBB, 0xCC, 0xDD) 1852 - abbccd -> (0xAB, 0xBC, 0xCD, 0xFF) 1853 - abbccdde -> (0xAB, 0xBC, 0xCD, 0xDE) 1854 """ 1855 try: 1856 out = [] 1857 if len(color) in (3,4): 1858 c = color 1859 color = '' 1860 for e in c: 1861 color += e + e 1862 if len(color) == 6: 1863 color += 'FF' 1864 if len(color) == 8: 1865 for i in range(0, 8, 2): 1866 out.append(int(color[i:i+2], 16)) 1867 return out 1868 except: 1869 pass 1870 return None
1871
1872 1873 -class ProxyObjectWrapper (object):
1874 - def __init__ (self, conn, func_str):
1875 self._obj = None 1876 self._func_str = func_str 1877 self._resyncConn(conn) 1878 self._tainted = False
1879
1880 - def clone (self):
1881 return ProxyObjectWrapper(self._conn, self._func_str)
1882
1883 - def _connect (self): #pragma: no cover
1884 """ 1885 Returns True if connected. 1886 1887 @return: Boolean 1888 """ 1889 1890 logger.debug("proxy_connect: a"); 1891 if not self._conn.connect(): 1892 logger.debug('connect failed') 1893 logger.debug('/n'.join(traceback.format_stack())) 1894 return False 1895 logger.debug("proxy_connect: b"); 1896 self._resyncConn(self._conn) 1897 logger.debug("proxy_connect: c"); 1898 self._obj = self._create_func() 1899 logger.debug("proxy_connect: d"); 1900 return True
1901
1902 - def taint (self):
1903 self._tainted = True
1904
1905 - def untaint (self):
1906 self._tainted = False
1907
1908 - def close (self):
1909 """ 1910 Closes the underlaying service, so next call to the proxy will create a new 1911 instance of it. 1912 """ 1913 1914 if self._obj: 1915 self._obj.close() 1916 self._obj = None
1917
1918 - def _resyncConn (self, conn):
1919 """ 1920 1921 @param conn: Connection 1922 """ 1923 1924 self._conn = conn 1925 self._sf = conn.c.sf 1926 self._create_func = getattr(self._sf, self._func_str) 1927 if self._obj is not None: 1928 try: 1929 logger.debug("## - refreshing %s" % (self._func_str)) 1930 obj = conn.c.ic.stringToProxy(str(self._obj)) 1931 self._obj = self._obj.checkedCast(obj) 1932 except Ice.ObjectNotExistException: 1933 self._obj = None
1934
1935 - def _getObj (self):
1936 """ 1937 1938 @return: obj 1939 """ 1940 if not self._obj: 1941 self._obj = self._create_func() 1942 else: 1943 self._ping() 1944 return self._obj
1945
1946 - def _ping (self): #pragma: no cover
1947 """ 1948 For some reason, it seems that keepAlive doesn't, so every so often I need to recreate the objects. 1949 1950 @return: Boolean 1951 """ 1952 1953 try: 1954 if not self._sf.keepAlive(self._obj): 1955 logger.debug("... died, recreating ...") 1956 self._obj = self._create_func() 1957 except Ice.ObjectNotExistException: 1958 # The connection is there, but it has been reset, because the proxy no longer exists... 1959 logger.debug("... reset, reconnecting") 1960 self._connect() 1961 return False 1962 except Ice.ConnectionLostException: 1963 # The connection was lost. This shouldn't happen, as we keep pinging it, but does so... 1964 logger.debug(traceback.format_stack()) 1965 logger.debug("... lost, reconnecting") 1966 self._conn._connected = False 1967 self._connect() 1968 return False 1969 except Ice.ConnectionRefusedException: 1970 # The connection was refused. We lost contact with glacier2router... 1971 logger.debug(traceback.format_stack()) 1972 logger.debug("... refused, reconnecting") 1973 self._connect() 1974 return False 1975 except omero.RemovedSessionException: 1976 # Session died on us 1977 logger.debug(traceback.format_stack()) 1978 logger.debug("... session has left the building, reconnecting") 1979 self._connect() 1980 return False 1981 except Ice.UnknownException: 1982 # Probably a wrapped RemovedSession 1983 logger.debug(traceback.format_stack()) 1984 logger.debug("... ice says something bad happened, reconnecting") 1985 self._connect() 1986 return False 1987 return True 1988
1989 - def __getattr__ (self, attr):
1990 """ 1991 1992 @param attr: Connection 1993 @return: rv 1994 """ 1995 # safe call wrapper 1996 obj = self._obj or self._getObj() 1997 rv = getattr(obj, attr) 1998 if callable(rv): 1999 rv = safeCallWrap(self, attr, rv) 2000 #self._conn.updateTimeout() 2001 return rv
2002
2003 2004 -class AnnotationWrapper (BlitzObjectWrapper):
2005 """ 2006 omero_model_AnnotationI class wrapper extends BlitzObjectWrapper. 2007 """ 2008 registry = {} 2009 OMERO_TYPE = None 2010
2011 - def __init__ (self, *args, **kwargs):
2012 super(AnnotationWrapper, self).__init__(*args, **kwargs) 2013 self.link = kwargs.has_key('link') and kwargs['link'] or None 2014 if self._obj is None and self.OMERO_TYPE is not None: 2015 self._obj = self.OMERO_TYPE()
2016
2017 - def __eq__ (self, a):
2018 return type(a) == type(self) and self._obj.id == a._obj.id and self.getValue() == a.getValue() and self.getNs() == a.getNs()
2019 2020 @classmethod
2021 - def _register (klass, regklass):
2022 klass.registry[regklass.OMERO_TYPE] = regklass
2023 2024 @classmethod
2025 - def _wrap (klass, conn, obj, link=None):
2026 if obj.__class__ in klass.registry: 2027 kwargs = dict() 2028 if link is not None: 2029 kwargs['link'] = BlitzObjectWrapper(conn, link) 2030 return klass.registry[obj.__class__](conn, obj, **kwargs) 2031 else: #pragma: no cover 2032 return None
2033 2034 @classmethod 2041
2042 - def getNs (self):
2043 return self._obj.ns.val
2044
2045 - def setNs (self, val):
2046 self._obj.ns = omero_type(val)
2047
2048 - def getValue (self): #pragma: no cover
2049 raise NotImplementedError
2050
2051 - def setValue (self, val): #pragma: no cover
2052 raise NotImplementedError 2053 2054 from omero_model_FileAnnotationI import FileAnnotationI
2055 2056 -class FileAnnotationWrapper (AnnotationWrapper):
2057 """ 2058 omero_model_FileAnnotatio class wrapper extends AnnotationWrapper. 2059 """ 2060 2061 OMERO_TYPE = FileAnnotationI 2062
2063 - def __loadedHotSwap__ (self):
2064 if not self._obj.file.loaded: 2065 self._obj._file = self._conn.getQueryService().find('OriginalFile', self._obj.file.id.val)
2066
2067 - def getValue (self):
2068 pass
2069
2070 - def setValue (self, val):
2071 pass
2072
2073 - def isOriginalMetadata(self):
2074 self.__loadedHotSwap__() 2075 try: 2076 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"): 2077 return True 2078 except: 2079 logger.info(traceback.format_exc()) 2080 return False
2081
2082 - def getFileSize(self):
2083 return self._obj.file.size.val
2084
2085 - def getFileName(self):
2086 self.__loadedHotSwap__() 2087 name = self._obj.file.name.val 2088 l = len(name) 2089 if l < 35: 2090 return name 2091 return name[:16] + "..." + name[l - 16:]
2092
2093 - def getFile(self):
2094 self.__loadedHotSwap__() 2095 store = self._conn.createRawFileStore() 2096 store.setFileId(self._obj.file.id.val) 2097 size = self.getFileSize() 2098 buf = 1048576 2099 if size <= buf: 2100 return store.read(0,long(size)) 2101 else: 2102 temp = "%s/%i-%s.download" % (settings.FILE_UPLOAD_TEMP_DIR, size, self._sessionUuid) 2103 outfile = open (temp, "wb") 2104 for pos in range(0,long(size),buf): 2105 data = None 2106 if size-pos < buf: 2107 data = store.read(pos+1, size-pos) 2108 else: 2109 if pos == 0: 2110 data = store.read(pos, buf) 2111 else: 2112 data = store.read(pos+1, buf) 2113 outfile.write(data) 2114 outfile.close() 2115 store.close() 2116 return temp 2117 return None
2118 2119 # def shortTag(self): 2120 # if isinstance(self._obj, TagAnnotationI): 2121 # try: 2122 # name = self._obj.textValue.val 2123 # l = len(name) 2124 # if l < 25: 2125 # return name 2126 # return name[:10] + "..." + name[l - 10:] 2127 # except: 2128 # logger.info(traceback.format_exc()) 2129 # return self._obj.textValue.val 2130 2131 AnnotationWrapper._register(FileAnnotationWrapper) 2132 2133 from omero_model_TimestampAnnotationI import TimestampAnnotationI
2134 2135 -class TimestampAnnotationWrapper (AnnotationWrapper):
2136 """ 2137 omero_model_TimestampAnnotatio class wrapper extends AnnotationWrapper. 2138 """ 2139 2140 OMERO_TYPE = TimestampAnnotationI 2141
2142 - def getValue (self):
2143 return datetime.fromtimestamp(self._obj.timeValue.val / 1000.0)
2144
2145 - def setValue (self, val):
2146 if isinstance(val, datetime): 2147 self._obj.timeValue = rtime(long(time.mktime(val.timetuple())*1000)) 2148 elif isinstance(val, omero.RTime): 2149 self._obj.timeValue = val 2150 else: 2151 self._obj.timeValue = rtime(long(val * 1000))
2152 2153 AnnotationWrapper._register(TimestampAnnotationWrapper) 2154 2155 from omero_model_BooleanAnnotationI import BooleanAnnotationI
2156 2157 -class BooleanAnnotationWrapper (AnnotationWrapper):
2158 """ 2159 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper. 2160 """ 2161 2162 OMERO_TYPE = BooleanAnnotationI 2163
2164 - def getValue (self):
2165 return self._obj.boolValue.val
2166
2167 - def setValue (self, val):
2168 self._obj.boolValue = rbool(not not val)
2169 2170 AnnotationWrapper._register(BooleanAnnotationWrapper) 2171 2172 from omero_model_TagAnnotationI import TagAnnotationI
2173 2174 -class TagAnnotationWrapper (AnnotationWrapper):
2175 """ 2176 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper. 2177 """ 2178 2179 OMERO_TYPE = TagAnnotationI 2180
2181 - def getValue (self):
2182 return self._obj.textValue.val
2183
2184 - def setValue (self, val):
2185 self._obj.tectValue = rbool(not not val)
2186 2187 AnnotationWrapper._register(TagAnnotationWrapper) 2188 2189 from omero_model_CommentAnnotationI import CommentAnnotationI
2190 2191 -class CommentAnnotationWrapper (AnnotationWrapper):
2192 """ 2193 omero_model_CommentAnnotationI class wrapper extends AnnotationWrapper. 2194 """ 2195 2196 OMERO_TYPE = CommentAnnotationI 2197
2198 - def getValue (self):
2199 return self._obj.textValue.val
2200
2201 - def setValue (self, val):
2202 self._obj.textValue = omero_type(val)
2203 2204 AnnotationWrapper._register(CommentAnnotationWrapper) 2205 2206 from omero_model_LongAnnotationI import LongAnnotationI
2207 2208 -class LongAnnotationWrapper (AnnotationWrapper):
2209 """ 2210 omero_model_LongAnnotationI class wrapper extends AnnotationWrapper. 2211 """ 2212 OMERO_TYPE = LongAnnotationI 2213
2214 - def getValue (self):
2215 return self._obj.longValue.val
2216
2217 - def setValue (self, val):
2218 self._obj.longValue = rlong(val)
2219 2220 AnnotationWrapper._register(LongAnnotationWrapper)
2221 2222 -class _EnumerationWrapper (BlitzObjectWrapper):
2223
2224 - def getType(self):
2225 return self._obj.__class__
2226 2227 EnumerationWrapper = _EnumerationWrapper
2228 2229 -class _ExperimenterWrapper (BlitzObjectWrapper):
2230 """ 2231 omero_model_ExperimenterI class wrapper extends BlitzObjectWrapper. 2232 """ 2233
2234 - def __bstrap__ (self):
2235 self.OMERO_CLASS = 'Experimenter' 2236 self.LINK_CLASS = "copyGroupExperimenterMap" 2237 self.CHILD_WRAPPER_CLASS = None 2238 self.PARENT_WRAPPER_CLASS = 'ExperimenterGroupWrapper'
2239
2240 - def simpleMarshal (self, xtra=None, parents=False):
2241 rv = super(_ExperimenterWrapper, self).simpleMarshal(xtra=xtra, parents=parents) 2242 rv.update({'firstName': self.firstName, 2243 'middleName': self.middleName, 2244 'lastName': self.lastName, 2245 'email': self.email, 2246 'isAdmin': len(filter(lambda x: x.name.val == 'system', self._conn.getAdminService().containedGroups(self.getId()))) == 1, 2247 }) 2248 return rv
2249
2250 - def getRawPreferences (self):
2251 """ Returns the experiments preferences annotation contents, as a ConfigParser instance """ 2252 self._obj.unloadAnnotationLinks() 2253 cp = ConfigParser.SafeConfigParser() 2254 prefs = self.getAnnotation('TODO.changeme.preferences') 2255 if prefs is not None: 2256 prefs = prefs.getValue() 2257 if prefs is not None: 2258 cp.readfp(StringIO(prefs)) 2259 return cp
2260
2261 - def setRawPreferences (self, prefs):
2262 """ Sets the experiments preferences annotation contents, passed in as a ConfigParser instance """ 2263 ann = self.getAnnotation('TODO.changeme.preferences') 2264 t = StringIO() 2265 prefs.write(t) 2266 if ann is None: 2267 ann = CommentAnnotationWrapper() 2268 ann.setNs('TODO.changeme.preferences') 2269 ann.setValue(t.getvalue()) 2270 self.linkAnnotation(ann) 2271 else: 2272 ann.setValue(t.getvalue()) 2273 ann.save() 2274 self._obj.unloadAnnotationLinks()
2275
2276 - def getPreference (self, key, default='', section=None):
2277 if section is None: 2278 section = 'DEFAULT' 2279 try: 2280 return self.getRawPreferences().get(section, key) 2281 except ConfigParser.Error: 2282 return default 2283 return default
2284
2285 - def getPreferences (self, section=None):
2286 if section is None: 2287 section = 'DEFAULT' 2288 prefs = self.getRawPreferences() 2289 if prefs.has_section(section) or section == 'DEFAULT': 2290 return dict(prefs.items(section)) 2291 return {}
2292
2293 - def setPreference (self, key, value, section=None):
2294 if section is None: 2295 section = 'DEFAULT' 2296 prefs = self.getRawPreferences() 2297 if not section in prefs.sections(): 2298 prefs.add_section(section) 2299 prefs.set(section, key, value) 2300 self.setRawPreferences(prefs)
2301
2302 - def getDetails (self):
2303 if not self._obj.details.owner: 2304 details = omero.model.DetailsI() 2305 details.owner = self._obj 2306 self._obj._details = details 2307 return DetailsWrapper(self._conn, self._obj.details)
2308
2309 - def getName (self):
2310 return self.omeName
2311
2312 - def getDescription (self):
2313 return self.getFullName()
2314
2315 - def getFullName (self):
2316 """ 2317 Gets full name of this experimenter. 2318 2319 @return: String or None 2320 """ 2321 2322 try: 2323 if self.middleName is not None and self.middleName != '': 2324 name = "%s %s. %s" % (self.firstName, self.middleName[:1].upper(), self.lastName) 2325 else: 2326 name = "%s %s" % (self.firstName, self.lastName) 2327 except: 2328 logger.error(traceback.format_exc()) 2329 name = self.omeName 2330 return name
2331
2332 - def getNameWithInitial(self):
2333 try: 2334 if self.firstName is not None and self.lastName is not None: 2335 name = "%s. %s" % (self.firstName[:1], self.lastName) 2336 else: 2337 name = self.omeName 2338 except: 2339 logger.error(traceback.format_exc()) 2340 name = self.omeName 2341 return name
2342
2343 - def isAdmin(self):
2344 for ob in self._obj.copyGroupExperimenterMap(): 2345 if ob.parent.name.val == "system": 2346 return True 2347 return False
2348
2349 - def isActive(self):
2350 for ob in self._obj.copyGroupExperimenterMap(): 2351 if ob.parent.name.val == "user": 2352 return True 2353 return False
2354
2355 - def isGuest(self):
2356 for ob in self._obj.copyGroupExperimenterMap(): 2357 if ob.parent.name.val == "guest": 2358 return True 2359 return False
2360 2361 ExperimenterWrapper = _ExperimenterWrapper
2362 2363 -class _ExperimenterGroupWrapper (BlitzObjectWrapper):
2364 """ 2365 omero_model_ExperimenterGroupI class wrapper extends BlitzObjectWrapper. 2366 """ 2367
2368 - def __bstrap__ (self):
2369 self.OMERO_CLASS = 'ExperimenterGroup' 2370 self.LINK_CLASS = "copyGroupExperimenterMap" 2371 self.CHILD_WRAPPER_CLASS = 'ExperimenterWrapper' 2372 self.PARENT_WRAPPER_CLASS = None
2373 2374 ExperimenterGroupWrapper = _ExperimenterGroupWrapper
2375 2376 -class DetailsWrapper (BlitzObjectWrapper):
2377 """ 2378 omero_model_DetailsI class wrapper extends BlitzObjectWrapper. 2379 """ 2380
2381 - def __init__ (self, *args, **kwargs):
2382 super(DetailsWrapper, self).__init__ (*args, **kwargs) 2383 owner = self._obj.getOwner() 2384 group = self._obj.getGroup() 2385 self._owner = owner and ExperimenterWrapper(self._conn, self._obj.getOwner()) or None 2386 self._group = group and ExperimenterGroupWrapper(self._conn, self._obj.getGroup()) or None
2387
2388 - def getOwner (self):
2389 return self._owner
2390
2391 - def getGroup (self):
2392 return self._group
2393
2394 -class _DatasetWrapper (BlitzObjectWrapper):
2395 """ 2396 omero_model_DatasetI class wrapper extends BlitzObjectWrapper. 2397 """ 2398
2399 - def __bstrap__ (self):
2400 self.OMERO_CLASS = 'Dataset' 2401 self.LINK_CLASS = "DatasetImageLink" 2402 self.CHILD_WRAPPER_CLASS = 'ImageWrapper' 2403 self.PARENT_WRAPPER_CLASS = 'ProjectWrapper'
2404
2405 - def __loadedHotSwap__ (self):
2406 super(_DatasetWrapper, self).__loadedHotSwap__() 2407 if not self._obj.isImageLinksLoaded(): 2408 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) 2409 self._obj._imageLinksLoaded = True 2410 self._obj._imageLinksSeq = links
2411 2412 DatasetWrapper = _DatasetWrapper
2413 2414 -class _ProjectWrapper (BlitzObjectWrapper):
2415 """ 2416 omero_model_ProjectI class wrapper extends BlitzObjectWrapper. 2417 """ 2418
2419 - def __bstrap__ (self):
2420 self.OMERO_CLASS = 'Project' 2421 self.LINK_CLASS = "ProjectDatasetLink" 2422 self.CHILD_WRAPPER_CLASS = 'DatasetWrapper' 2423 self.PARENT_WRAPPER_CLASS = None
2424 2425 ProjectWrapper = _ProjectWrapper
2426 2427 #class CategoryWrapper (BlitzObjectWrapper): 2428 # def __bstrap__ (self): 2429 # self.LINK_CLASS = "CategoryImageLink" 2430 # self.CHILD_WRAPPER_CLASS = ImageWrapper 2431 # self.PARENT_WRAPPER_CLASS= 'CategoryGroupWrapper' 2432 # 2433 #class CategoryGroupWrapper (BlitzObjectWrapper): 2434 # def __bstrap__ (self): 2435 # self.LINK_CLASS = "CategoryGroupCategoryLink" 2436 # self.CHILD_WRAPPER_CLASS = CategoryWrapper 2437 # self.PARENT_WRAPPER_CLASS = None 2438 2439 ## IMAGE ## 2440 2441 -class ColorHolder (object):
2442 """ 2443 Stores color internally as (R,G,B,A) and allows setting and getting in multiple formats 2444 """ 2445 2446 _color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255} 2447
2448 - def __init__ (self, colorname=None):
2449 self._color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255} 2450 if colorname and colorname.lower() in self._color.keys(): 2451 self._color[colorname.lower()] = 255
2452 2453 @classmethod
2454 - def fromRGBA(klass,r,g,b,a):
2455 rv = klass() 2456 rv.setRed(r) 2457 rv.setGreen(g) 2458 rv.setBlue(b) 2459 rv.setAlpha(a) 2460 return rv
2461
2462 - def getRed (self):
2463 return self._color['red']
2464
2465 - def setRed (self, val):
2466 """ 2467 Set red, as int 0..255 2468 2469 @param val: value of Red. 2470 """ 2471 2472 self._color['red'] = max(min(255, int(val)), 0)
2473
2474 - def getGreen (self):
2475 return self._color['green']
2476
2477 - def setGreen (self, val):
2478 """ 2479 Set green, as int 0..255 2480 2481 @param val: value of Green. 2482 """ 2483 2484 self._color['green'] = max(min(255, int(val)), 0)
2485
2486 - def getBlue (self):
2487 return self._color['blue']
2488
2489 - def setBlue (self, val):
2490 """ 2491 Set Blue, as int 0..255 2492 2493 @param val: value of Blue. 2494 """ 2495 2496 self._color['blue'] = max(min(255, int(val)), 0)
2497
2498 - def getAlpha (self):
2499 return self._color['alpha']
2500
2501 - def setAlpha (self, val):
2502 """ 2503 Set alpha, as int 0..255. 2504 @param val: value of alpha. 2505 """ 2506 2507 self._color['alpha'] = max(min(255, int(val)), 0)
2508
2509 - def getHtml (self):
2510 """ 2511 @return: String. The html usable color. Dumps the alpha information. 2512 """ 2513 2514 return "%(red)0.2X%(green)0.2X%(blue)0.2X" % (self._color)
2515
2516 - def getCss (self):
2517 """ 2518 @return: String. rgba(r,g,b,a) for this color. 2519 """ 2520 2521 c = self._color.copy() 2522 c['alpha'] /= 255.0 2523 return "rgba(%(red)i,%(green)i,%(blue)i,%(alpha)0.3f)" % (c)
2524
2525 - def getRGB (self):
2526 """ 2527 @return: list. A list of (r,g,b) values 2528 """ 2529 2530 return (self._color['red'], self._color['green'], self._color['blue'])
2531
2532 -class _LogicalChannelWrapper (BlitzObjectWrapper):
2533 """ 2534 omero_model_LogicalChannelI class wrapper extends BlitzObjectWrapper. 2535 """ 2536 _attrs = ('name', 2537 'pinHoleSize', 2538 '#illumination', 2539 'contrastMethod', 2540 'excitationWave', 2541 'emissionWave', 2542 'fluor', 2543 'ndFilter', 2544 'otf', 2545 'detectorSettings|DetectorSettingsWrapper', 2546 'lightSourceSettings|LightSettingsWrapper', 2547 'filterSet|FilterSetWrapper', 2548 'lightPath|LightPathWrapper', 2549 'samplesPerPixel', 2550 '#photometricInterpretation', 2551 'mode', 2552 'pockelCellSetting', 2553 'shapes', 2554 'version')
2555 2556 LogicalChannelWrapper = _LogicalChannelWrapper
2557 2558 -class _LightPathWrapper (BlitzObjectWrapper):
2559 """ 2560 base Light Source class wrapper, extends BlitzObjectWrapper. 2561 """ 2562 _attrs = ('dichroic|DichroicWrapper') 2563 # 'copyEmissionFilter|FilterWrapper', 2564 # 'copyExcitationFilter|FilterWrapper', 2565
2566 - def __bstrap__ (self):
2567 self.OMERO_CLASS = 'LightPath'
2568
2569 - def copyEmissionFilters(self):
2570 pass
2571
2572 - def copyExcitationFilters(self):
2573 pass
2574 2575 LightPathWrapper = _LightPathWrapper
2576 2577 -class _ChannelWrapper (BlitzObjectWrapper):
2578 """ 2579 omero_model_ChannelI class wrapper extends BlitzObjectWrapper. 2580 """ 2581 2582 BLUE_MIN = 400 2583 BLUE_MAX = 500 2584 GREEN_MIN = 501 2585 GREEN_MAX = 600 2586 RED_MIN = 601 2587 RED_MAX = 700 2588 COLOR_MAP = ((BLUE_MIN, BLUE_MAX, ColorHolder('Blue')), 2589 (GREEN_MIN, GREEN_MAX, ColorHolder('Green')), 2590 (RED_MIN, RED_MAX, ColorHolder('Red')), 2591 ) 2592
2593 - def __bstrap__ (self):
2594 self.OMERO_CLASS = 'Channel'
2595
2596 - def __prepare__ (self, idx=-1, re=None, img=None):
2597 self._re = re 2598 self._idx = idx 2599 self._img = img
2600
2601 - def save (self):
2602 self._obj.setPixels(omero.model.PixelsI(self._obj.getPixels().getId(), False)) 2603 return super(_ChannelWrapper, self).save()
2604
2605 - def isActive (self):
2606 return self._re.isActive(self._idx)
2607
2608 - def getLogicalChannel (self):
2609 if self._obj.logicalChannel is not None: 2610 return LogicalChannelWrapper(self._conn, self._obj.logicalChannel)
2611
2612 - def getEmissionWave (self):
2613 lc = self.getLogicalChannel() 2614 rv = lc.name 2615 if rv is None: 2616 rv = lc.emissionWave 2617 if rv is None: 2618 rv = self._idx 2619 return rv
2620
2621 - def getColor (self):
2622 return ColorHolder.fromRGBA(*self._re.getRGBA(self._idx))
2623
2624 - def getWindowStart (self):
2625 return int(self._re.getChannelWindowStart(self._idx))
2626
2627 - def setWindowStart (self, val):
2628 self.setWindow(val, self.getWindowEnd())
2629
2630 - def getWindowEnd (self):
2631 return int(self._re.getChannelWindowEnd(self._idx))
2632
2633 - def setWindowEnd (self, val):
2634 self.setWindow(self.getWindowStart(), val)
2635
2636 - def setWindow (self, minval, maxval):
2637 self._re.setChannelWindow(self._idx, float(minval), float(maxval))
2638
2639 - def getWindowMin (self):
2640 return self._obj.getStatsInfo().getGlobalMin().val
2641
2642 - def getWindowMax (self):
2643 return self._obj.getStatsInfo().getGlobalMax().val
2644 2645 ChannelWrapper = _ChannelWrapper
2646 2647 -def assert_re (func):
2648 def wrapped (self, *args, **kwargs): 2649 if not self._prepareRenderingEngine(): 2650 return None 2651 return func(self, *args, **kwargs)
2652 return wrapped 2653
2654 -def assert_pixels (func):
2655 def wrapped (self, *args, **kwargs): 2656 if not self._loadPixels(): 2657 return None 2658 return func(self, *args, **kwargs)
2659 return wrapped 2660
2661 2662 -class _ImageWrapper (BlitzObjectWrapper):
2663 """ 2664 omero_model_ImageI class wrapper extends BlitzObjectWrapper. 2665 """ 2666 2667 _re = None 2668 _pd = None 2669 _rm = {} 2670 _pixels = None 2671 2672 _pr = None # projection 2673 2674 PROJECTIONS = { 2675 'normal': -1, 2676 'intmax': omero.constants.projection.ProjectionType.MAXIMUMINTENSITY, 2677 'intmean': omero.constants.projection.ProjectionType.MEANINTENSITY, 2678 'intsum': omero.constants.projection.ProjectionType.SUMINTENSITY, 2679 } 2680 2681 PLANEDEF = omero.romio.XY 2682 2683 @classmethod
2684 - def fromPixelsId (self, conn, pid):
2685 q = conn.getQueryService() 2686 p = q.find('Pixels', pid) 2687 if p is None: 2688 return None 2689 return ImageWrapper(conn, p.image)
2690
2691 - def __bstrap__ (self):
2692 self.OMERO_CLASS = 'Image' 2693 self.LINK_CLASS = None 2694 self.CHILD_WRAPPER_CLASS = None 2695 self.PARENT_WRAPPER_CLASS = 'DatasetWrapper'
2696
2697 - def __del__ (self):
2698 self._re and self._re.untaint()
2699
2700 - def __loadedHotSwap__ (self):
2701 self._obj = self._conn.getContainerService().getImages(self.OMERO_CLASS, (self._oid,), None)[0]
2702
2703 - def getInstrument (self):
2704 i = self._obj.instrument 2705 if i is None: 2706 return None 2707 if not i.loaded: 2708 self._obj.instrument = self._conn.getQueryService().find('Instrument', i.id.val) 2709 i = self._obj.instrument 2710 meta_serv = self._conn.getMetadataService() 2711 for e in meta_serv.loadInstrument(i.id.val): 2712 if isinstance(e, omero.model.DetectorI): 2713 i._detectorSeq.append(e) 2714 elif isinstance(e, omero.model.ObjectiveI): 2715 i._objectiveSeq.append(e) 2716 elif isinstance(e, omero.model.LightSource): 2717 i._lightSourceSeq.append(e) 2718 elif isinstance(e, omero.model.FilterI): 2719 i._filterSeq.append(e) 2720 elif isinstance(e, omero.model.DichroicI): 2721 i._dichroicSeq.append(e) 2722 elif isinstance(e, omero.model.FilterSetI): 2723 i._filterSetSeq.append(e) 2724 elif isinstance(e, omero.model.OTFI): 2725 i._otfSeq.append(e) 2726 elif isinstance(e, omero.model.InstrumentI): 2727 pass 2728 else: 2729 logger.info("Unknown instrument entry: %s" % str(e)) 2730 return InstrumentWrapper(self._conn, i)
2731
2732 - def _loadPixels (self):
2733 if not self._obj.pixelsLoaded: 2734 self.__loadedHotSwap__() 2735 return self._obj.sizeOfPixels() > 0
2736
2737 - def _prepareRE (self):
2738 re = self._conn.createRenderingEngine() 2739 pixels_id = self._obj.getPrimaryPixels().id.val 2740 re.lookupPixels(pixels_id) 2741 if re.lookupRenderingDef(pixels_id) == False: #pragma: no cover 2742 try: 2743 re.resetDefaults() 2744 except omero.ResourceError: 2745 # broken image 2746 return False 2747 re.lookupRenderingDef(pixels_id) 2748 re.load() 2749 return re
2750
2751 - def _prepareRenderingEngine (self):
2752 self._loadPixels() 2753 if self._re is None: 2754 if self._obj.sizeOfPixels() < 1: 2755 return False 2756 if self._pd is None: 2757 self._pd = omero.romio.PlaneDef(self.PLANEDEF) 2758 self._re = self._prepareRE() 2759 return self._re is not None
2760
2761 - def resetRDefs (self):
2762 logger.debug('resetRDefs') 2763 if self.canWrite(): 2764 self._conn.getDeleteService().deleteSettings(self.getId()) 2765 return True 2766 return False
2767
2768 - def simpleMarshal (self, xtra=None, parents=False):
2769 rv = super(_ImageWrapper, self).simpleMarshal(xtra=xtra, parents=parents) 2770 rv.update({'author': self.getAuthor(), 2771 'date': time.mktime(self.getDate().timetuple()),}) 2772 if xtra: 2773 if xtra.has_key('thumbUrlPrefix'): 2774 if callable(xtra['thumbUrlPrefix']): 2775 rv['thumb_url'] = xtra['thumbUrlPrefix'](str(self.id)) 2776 else: 2777 rv['thumb_url'] = xtra['thumbUrlPrefix'] + str(self.id) + '/' 2778 return rv
2779
2780 - def getStageLabel (self):
2781 if self._obj.stageLabel is None: 2782 return None 2783 else: 2784 return ImageStageLabelWrapper(self._conn, self._obj.stageLabel)
2785
2786 - def shortname(self, length=20, hist=5):
2787 name = self.name 2788 if not name: 2789 return "" 2790 l = len(name) 2791 if l < length+hist: 2792 return name 2793 return "..." + name[l - length:]
2794
2795 - def getAuthor(self):
2796 q = self._conn.getQueryService() 2797 e = q.findByQuery("select e from Experimenter e where e.id = %i" % self._obj.details.owner.id.val,None) 2798 self._author = e.firstName.val + " " + e.lastName.val 2799 return self._author
2800
2801 - def getDataset(self):
2802 try: 2803 q = """ 2804 select ds from Image i join i.datasetLinks dl join dl.parent ds 2805 where i.id = %i 2806 """ % self._obj.id.val 2807 query = self._conn.getQueryService() 2808 ds = query.findByQuery(q,None) 2809 return ds and DatasetWrapper(self._conn, ds) or None 2810 except: #pragma: no cover 2811 logger.debug('on getDataset') 2812 logger.debug(traceback.format_exc()) 2813 return None
2814
2815 - def getProject(self):
2816 try: 2817 q = """ 2818 select p from Image i join i.datasetLinks dl join dl.parent ds join ds.projectLinks pl join pl.parent p 2819 where i.id = %i 2820 """ % self._obj.id.val 2821 query = self._conn.getQueryService() 2822 prj = query.findByQuery(q,None) 2823 return prj and ProjectWrapper(self._conn, prj) or None 2824 except: #pragma: no cover 2825 logger.debug('on getProject') 2826 logger.debug(traceback.format_exc()) 2827 return None
2828
2829 - def getDate(self):
2830 try: 2831 query = self._conn.getQueryService() 2832 event = query.findByQuery("select e from Event e where id = %i" % self._obj.details.creationEvent.id.val, None) 2833 return datetime.fromtimestamp(event.time.val / 1000) 2834 except: # pragma: no cover 2835 logger.debug('on getDate') 2836 logger.debug(traceback.format_exc()) 2837 #self._date = "Today" 2838 return datetime.fromtimestamp(event.time.val / 1000) #"Today"
2839
2840 - def getObjectiveSettings (self):
2841 rv = self.objectiveSettings 2842 if self.objectiveSettings is not None: 2843 rv = ObjectiveSettingsWrapper(self._conn, self.objectiveSettings) 2844 if not self.objectiveSettings.loaded: 2845 self.objectiveSettings = rv._obj 2846 return rv
2847
2848 - def getImagingEnvironment (self):
2849 rv = self.imagingEnvironment 2850 if self.imagingEnvironment is not None: 2851 rv = ImagingEnvironmentWrapper(self._conn, self.imagingEnvironment) 2852 if not self.imagingEnvironment.loaded: 2853 self.imagingEnvironment = rv._obj 2854 return rv
2855 2856 @assert_pixels
2857 - def getPrimaryPixels (self):
2858 return self._obj.getPrimaryPixels()
2859 2860 @assert_pixels
2861 - def getPixelsId (self):
2862 return self._obj.getPrimaryPixels().getId().val
2863
2864 - def _prepareTB (self):
2865 pixels_id = self.getPixelsId() 2866 if pixels_id is None: 2867 return None 2868 tb = self._conn.createThumbnailStore() 2869 try: 2870 rv = tb.setPixelsId(pixels_id) 2871 except omero.InternalException: 2872 logger.error(traceback.print_exc()) 2873 rv = False 2874 if not rv: #pragma: no cover 2875 tb.resetDefaults() 2876 tb.close() 2877 tb.setPixelsId(pixels_id) 2878 return tb
2879
2880 - def loadOriginalMetadata(self):
2881 global_metadata = list() 2882 series_metadata = list() 2883 if self is not None: 2884 for a in self.listAnnotations(): 2885 if isinstance(a._obj, FileAnnotationI) and a.isOriginalMetadata(): 2886 temp_file = a.getFile().split('\n') 2887 flag = None 2888 for l in temp_file: 2889 if l.startswith("[GlobalMetadata]"): 2890 flag = 1 2891 elif l.startswith("[SeriesMetadata]"): 2892 flag = 2 2893 else: 2894 if len(l) < 1: 2895 l = None 2896 else: 2897 l = tuple(l.split("=")) 2898 if l is not None: 2899 if flag == 1: 2900 global_metadata.append(l) 2901 elif flag == 2: 2902 series_metadata.append(l) 2903 return (a, (global_metadata), (series_metadata)) 2904 return None
2905
2906 - def getThumbnail (self, size=(64,64), z=None, t=None):
2907 try: 2908 tb = self._prepareTB() 2909 if tb is None: 2910 return None 2911 if isinstance(size, IntType): 2912 size = (size,) 2913 if z is not None and t is not None: 2914 pos = z,t 2915 else: 2916 pos = None 2917 if len(size) == 1: 2918 if pos is None: 2919 thumb = tb.getThumbnailByLongestSideDirect 2920 else: 2921 thumb = tb.getThumbnailForSectionByLongestSideDirect 2922 else: 2923 if pos is None: 2924 thumb = tb.getThumbnailDirect 2925 else: 2926 thumb = tb.getThumbnailForSectionDirect 2927 args = map(lambda x: rint(x), size) 2928 if pos is not None: 2929 args = list(pos) + args 2930 rv = thumb(*args) 2931 return rv 2932 except Exception: #pragma: no cover 2933 logger.error(traceback.print_exc()) 2934 return None
2935 2936 @assert_pixels
2937 - def getPixelRange (self):
2938 """ Returns (min, max) values for the pixels type of this image. 2939 TODO: Does not handle floats correctly, though.""" 2940 pixels_id = self._obj.getPrimaryPixels().getId().val 2941 rp = self._conn.createRawPixelsStore() 2942 rp.setPixelsId(pixels_id, True) 2943 pmax = 2 ** (8 * rp.getByteWidth()) 2944 if rp.isSigned(): 2945 return (-(pmax / 2), pmax / 2 - 1) 2946 else: 2947 return (0, pmax-1)
2948 2949 @assert_re
2950 - def getChannels (self):
2951 return [ChannelWrapper(self._conn, c, idx=n, re=self._re, img=self) for n,c in enumerate(self._re.getPixels().iterateChannels())]
2952
2953 - def setActiveChannels(self, channels, windows=None, colors=None):
2954 for c in range(len(self.getChannels())): 2955 self._re.setActive(c, (c+1) in channels) 2956 if (c+1) in channels: 2957 if windows is not None and windows[c][0] is not None and windows[c][1] is not None: 2958 self._re.setChannelWindow(c, *windows[c]) 2959 if colors is not None and colors[c]: 2960 rgba = splitHTMLColor(colors[c]) 2961 if rgba: 2962 self._re.setRGBA(c, *rgba) 2963 return True
2964
2965 - def getProjections (self):
2966 return self.PROJECTIONS.keys()
2967
2968 - def setProjection (self, proj):
2969 self._pr = proj
2970 2971 LINE_PLOT_DTYPES = { 2972 (4, True, True): 'f', # signed float 2973 (2, False, False): 'H', # unsigned short 2974 (2, False, True): 'h', # signed short 2975 (1, False, False): 'B', # unsigned char 2976 (1, False, True): 'b', # signed char 2977 } 2978
2979 - def getPixelLine (self, z, t, pos, axis, channels=None, range=None):
2980 """ 2981 Grab a horizontal or vertical line from the image pixel data, for the specified channels 2982 (or all if not specified) and using the specified range (or 1:1 relative to the image size). 2983 Axis may be 'h' or 'v', for horizontal or vertical respectively. 2984 2985 @param z: 2986 @param t: 2987 @param pos: 2988 @param axis: 2989 @param channels: 2990 @param range: 2991 @return: rv 2992 """ 2993 2994 if not self._loadPixels(): 2995 logger.debug( "No pixels!") 2996 return None 2997 axis = axis.lower()[:1] 2998 if channels is None: 2999 channels = map(lambda x: x._idx, filter(lambda x: x.isActive(), self.getChannels())) 3000 if range is None: 3001 range = axis == 'h' and self.getHeight() or self.getWidth() 3002 if not isinstance(channels, (TupleType, ListType)): 3003 channels = (channels,) 3004 chw = map(lambda x: (x.getWindowMin(), x.getWindowMax()), self.getChannels()) 3005 rv = [] 3006 pixels_id = self._obj.getPrimaryPixels().getId().val 3007 rp = self._conn.createRawPixelsStore() 3008 rp.setPixelsId(pixels_id, True) 3009 for c in channels: 3010 bw = rp.getByteWidth() 3011 key = self.LINE_PLOT_DTYPES.get((bw, rp.isFloat(), rp.isSigned()), None) 3012 if key is None: 3013 logger.error("Unknown data type: " + str((bw, rp.isFloat(), rp.isSigned()))) 3014 plot = array.array(key, axis == 'h' and rp.getRow(pos, z, c, t) or rp.getCol(pos, z, c, t)) 3015 plot.byteswap() # TODO: Assuming ours is a little endian system 3016 # now move data into the windowMin..windowMax range 3017 offset = -chw[c][0] 3018 if offset != 0: 3019 plot = map(lambda x: x+offset, plot) 3020 normalize = 1.0/chw[c][1]*(range-1) 3021 if normalize != 1.0: 3022 plot = map(lambda x: x*normalize, plot) 3023 if isinstance(plot, array.array): 3024 plot = plot.tolist() 3025 rv.append(plot) 3026 return rv
3027 3028
3029 - def getRow (self, z, t, y, channels=None, range=None):
3030 return self.getPixelLine(z,t,y,'h',channels,range)
3031
3032 - def getCol (self, z, t, x, channels=None, range=None):
3033 return self.getPixelLine(z,t,x,'v',channels,range)
3034 3035 @assert_re
3036 - def getRenderingModels (self):
3037 if not len(self._rm): 3038 for m in [BlitzObjectWrapper(self._conn, m) for m in self._re.getAvailableModels()]: 3039 self._rm[m.value.lower()] = m 3040 return self._rm.values()
3041 3042 @assert_re
3043 - def getRenderingModel (self):
3044 return BlitzObjectWrapper(self._conn, self._re.getModel())
3045
3046 - def setGreyscaleRenderingModel (self):
3047 """ 3048 Sets the Greyscale rendering model on this image's current renderer 3049 """ 3050 3051 rm = self.getRenderingModels() 3052 self._re.setModel(self._rm.get('greyscale', rm[0])._obj)
3053
3054 - def setColorRenderingModel (self):
3055 """ 3056 Sets the HSB rendering model on this image's current renderer 3057 """ 3058 3059 rm = self.getRenderingModels() 3060 self._re.setModel(self._rm.get('rgb', rm[0])._obj)
3061
3062 - def isGreyscaleRenderingModel (self):
3063 return self.getRenderingModel().value.lower() == 'greyscale'
3064 3065 @assert_re
3066 - def renderJpeg (self, z, t, compression=0.9):
3067 self._pd.z = long(z) 3068 self._pd.t = long(t) 3069 try: 3070 if compression is not None: 3071 try: 3072 self._re.setCompressionLevel(float(compression)) 3073 except omero.SecurityViolation: #pragma: no cover 3074 self._obj.clearPixels() 3075 self._obj.pixelsLoaded = False 3076 self._re = None 3077 return self.renderJpeg(z,t,None) 3078 projection = self.PROJECTIONS.get(self._pr, -1) 3079 if not isinstance(projection, omero.constants.projection.ProjectionType): 3080 rv = self._re.renderCompressed(self._pd) 3081 else: 3082 rv = self._re.renderProjectedCompressed(projection, self._pd.t, 1, 0, self.z_count()-1) 3083 return rv 3084 except omero.InternalException: #pragma: no cover 3085 logger.debug('On renderJpeg'); 3086 logger.debug(traceback.format_exc()) 3087 return None 3088 except Ice.MemoryLimitException: #pragma: no cover 3089 # Make sure renderCompressed isn't called again on this re, as it hangs 3090 self._obj.clearPixels() 3091 self._obj.pixelsLoaded = False 3092 self._re = None 3093 raise
3094
3095 - def exportOmeTiff (self):
3096 e = self._conn.createExporter() 3097 e.addImage(self.getId()) 3098 size = e.generateTiff() 3099 p = 0 3100 rv = '' 3101 while p < size: 3102 s = min(65536, size-p) 3103 rv += e.read(p,s) 3104 p += s 3105 e.close() 3106 return rv
3107
3108 - def renderImage (self, z, t, compression=0.9):
3109 rv = self.renderJpeg(z,t,compression) 3110 if rv is not None: 3111 i = StringIO(rv) 3112 rv = Image.open(i) 3113 return rv
3114
3115 - def renderSplitChannel (self, z, t, compression=0.9, border=2):
3116 """ 3117 Prepares a jpeg representation of a 2d grid holding a render of each channel, 3118 along with one for all channels at the set Z and T points. 3119 3120 @param z: 3121 @param t: 3122 @param compression: 3123 @param border: 3124 @return: value 3125 """ 3126 3127 img = self.renderSplitChannelImage(z,t,compression, border) 3128 rv = StringIO() 3129 img.save(rv, 'jpeg', quality=int(compression*100)) 3130 return rv.getvalue()
3131
3132 - def splitChannelDims (self, border=2):
3133 c = self.c_count() 3134 # Greyscale, no channel overlayed image 3135 x = sqrt(c) 3136 y = int(round(x)) 3137 if x > y: 3138 x = y+1 3139 else: 3140 x = y 3141 rv = {'g':{'width': self.getWidth()*x + border*(x+1), 3142 'height': self.getHeight()*y+border*(y+1), 3143 'border': border, 3144 'gridx': x, 3145 'gridy': y,} 3146 } 3147 # Color, one extra image with all channels overlayed 3148 c += 1 3149 x = sqrt(c) 3150 y = int(round(x)) 3151 if x > y: 3152 x = y+1 3153 else: 3154 x = y 3155 rv['c'] = {'width': self.getWidth()*x + border*(x+1), 3156 'height': self.getHeight()*y+border*(y+1), 3157 'border': border, 3158 'gridx': x, 3159 'gridy': y,} 3160 return rv
3161
3162 - def renderSplitChannelImage (self, z, t, compression=0.9, border=2):
3163 """ 3164 Prepares a PIL Image with a 2d grid holding a render of each channel, 3165 along with one for all channels at the set Z and T points. 3166 3167 @param z: 3168 @param t: 3169 @param compression: 3170 @param border: 3171 @return: canvas 3172 """ 3173 3174 dims = self.splitChannelDims(border=border)[self.isGreyscaleRenderingModel() and 'g' or 'c'] 3175 canvas = Image.new('RGBA', (dims['width'], dims['height']), '#fff') 3176 cmap = [ch.isActive() and i+1 or 0 for i,ch in enumerate(self.getChannels())] 3177 c = self.c_count() 3178 pxc = 0 3179 px = dims['border'] 3180 py = dims['border'] 3181 3182 # Font sizes depends on image width 3183 w = self.getWidth() 3184 if w >= 640: 3185 fsize = (int((w-640)/128)*8) + 24 3186 if fsize > 64: 3187 fsize = 64 3188 elif w >= 512: 3189 fsize = 24 3190 elif w >= 384: #pragma: no cover 3191 fsize = 18 3192 elif w >= 298: #pragma: no cover 3193 fsize = 14 3194 elif w >= 256: #pragma: no cover 3195 fsize = 12 3196 elif w >= 213: #pragma: no cover 3197 fsize = 10 3198 elif w >= 96: #pragma: no cover 3199 fsize = 8 3200 else: #pragma: no cover 3201 fsize = 0 3202 if fsize > 0: 3203 font = ImageFont.load('%s/pilfonts/B%0.2d.pil' % (THISPATH, fsize) ) 3204 3205 3206 for i in range(c): 3207 if cmap[i]: 3208 self.setActiveChannels((i+1,)) 3209 img = self.renderImage(z,t, compression) 3210 if fsize > 0: 3211 draw = ImageDraw.ImageDraw(img) 3212 draw.text((2,2), "w=%s" % (str(self.getChannels()[i].getEmissionWave())), font=font, fill="#fff") 3213 canvas.paste(img, (px, py)) 3214 pxc += 1 3215 if pxc < dims['gridx']: 3216 px += self.getWidth() + border 3217 else: 3218 pxc = 0 3219 px = border 3220 py += self.getHeight() + border 3221 if not self.isGreyscaleRenderingModel(): 3222 self.setActiveChannels(cmap) 3223 img = self.renderImage(z,t, compression) 3224 if fsize > 0: 3225 draw = ImageDraw.ImageDraw(img) 3226 draw.text((2,2), "combined", font=font, fill="#fff") 3227 canvas.paste(img, (px, py)) 3228 return canvas
3229 3230 LP_PALLETE = [0,0,0,0,0,0,255,255,255] 3231 LP_TRANSPARENT = 0 # Some color 3232 LP_BGCOLOR = 1 # Black 3233 LP_FGCOLOR = 2 # white
3234 - def prepareLinePlotCanvas (self, z, t):
3235 """ 3236 Common part of horizontal and vertical line plot rendering. 3237 @returns: (Image, width, height). 3238 """ 3239 channels = filter(lambda x: x.isActive(), self.getChannels()) 3240 width = self.getWidth() 3241 height = self.getHeight() 3242 3243 pal = list(self.LP_PALLETE) 3244 # Prepare the palette taking channel colors in consideration 3245 for channel in channels: 3246 pal.extend(channel.getColor().getRGB()) 3247 3248 # Prepare the PIL classes we'll be using 3249 im = Image.new('P', (width, height)) 3250 im.putpalette(pal) 3251 return im, width, height
3252 3253 3254 @assert_re
3255 - def renderRowLinePlotGif (self, z, t, y, linewidth=1):
3256 self._pd.z = long(z) 3257 self._pd.t = long(t) 3258 3259 im, width, height = self.prepareLinePlotCanvas(z,t) 3260 base = height - 1 3261 3262 draw = ImageDraw.ImageDraw(im) 3263 # On your marks, get set... go! 3264 draw.rectangle([0, 0, width-1, base], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT) 3265 draw.line(((0,y),(width, y)), fill=self.LP_FGCOLOR, width=linewidth) 3266 3267 # Grab row data 3268 rows = self.getRow(z,t,y) 3269 3270 for r in range(len(rows)): 3271 chrow = rows[r] 3272 color = r + self.LP_FGCOLOR + 1 3273 last_point = base-chrow[0] 3274 for i in range(len(chrow)): 3275 draw.line(((i, last_point), (i, base-chrow[i])), fill=color, width=linewidth) 3276 last_point = base-chrow[i] 3277 del draw 3278 out = StringIO() 3279 im.save(out, format="gif", transparency=0) 3280 return out.getvalue()
3281 3282 @assert_re
3283 - def renderColLinePlotGif (self, z, t, x, linewidth=1):
3284 self._pd.z = long(z) 3285 self._pd.t = long(t) 3286 3287 im, width, height = self.prepareLinePlotCanvas(z,t) 3288 3289 draw = ImageDraw.ImageDraw(im) 3290 # On your marks, get set... go! 3291 draw.rectangle([0, 0, width-1, height-1], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT) 3292 draw.line(((x,0),(x, height)), fill=self.LP_FGCOLOR, width=linewidth) 3293 3294 # Grab col data 3295 cols = self.getCol(z,t,x) 3296 3297 for r in range(len(cols)): 3298 chcol = cols[r] 3299 color = r + self.LP_FGCOLOR + 1 3300 last_point = chcol[0] 3301 for i in range(len(chcol)): 3302 draw.line(((last_point, i), (chcol[i], i)), fill=color, width=linewidth) 3303 last_point = chcol[i] 3304 del draw 3305 out = StringIO() 3306 im.save(out, format="gif", transparency=0) 3307 return out.getvalue()
3308 3309 @assert_re
3310 - def getZ (self):
3311 return self._pd.z
3312 3313 @assert_re
3314 - def getT (self):
3315 return self._pd.t
3316 3317 @assert_pixels
3318 - def getPixelSizeX (self):
3319 rv = self._obj.getPrimaryPixels().getPhysicalSizeX() 3320 return rv is not None and rv.val or 0
3321 3322 @assert_pixels
3323 - def getPixelSizeY (self):
3324 rv = self._obj.getPrimaryPixels().getPhysicalSizeY() 3325 return rv is not None and rv.val or 0
3326 3327 @assert_pixels
3328 - def getPixelSizeZ (self):
3329 rv = self._obj.getPrimaryPixels().getPhysicalSizeZ() 3330 return rv is not None and rv.val or 0
3331 3332 @assert_pixels
3333 - def getWidth (self):
3334 return self._obj.getPrimaryPixels().getSizeX().val
3335 3336 @assert_pixels
3337 - def getHeight (self):
3338 return self._obj.getPrimaryPixels().getSizeY().val
3339 3340 @assert_pixels
3341 - def z_count (self):
3342 return self._obj.getPrimaryPixels().getSizeZ().val
3343 3344 @assert_pixels
3345 - def t_count (self):
3346 return self._obj.getPrimaryPixels().getSizeT().val
3347 3348 @assert_pixels
3349 - def c_count (self):
3350 return self._obj.getPrimaryPixels().getSizeC().val
3351
3352 - def clearDefaults (self):
3353 """ 3354 Removes specific color settings from channels 3355 3356 @return: Boolean 3357 """ 3358 3359 if not self.canWrite(): 3360 return False 3361 for c in self.getChannels(): 3362 c.unloadRed() 3363 c.unloadGreen() 3364 c.unloadBlue() 3365 c.unloadAlpha() 3366 c.save() 3367 self._conn.getDeleteService().deleteSettings(self.getId()) 3368 return True
3369 3370 @assert_re
3371 - def saveDefaults (self):
3372 """ 3373 Limited support for saving the current prepared image rendering defs. 3374 Right now only channel colors are saved back. 3375 3376 @return: Boolean 3377 """ 3378 3379 if not self.canWrite(): 3380 return False 3381 self._re.saveCurrentSettings() 3382 return True
3383 3384 ImageWrapper = _ImageWrapper
3385 3386 ## INSTRUMENT AND ACQUISITION ## 3387 3388 -class _ImageStageLabelWrapper (BlitzObjectWrapper):
3389 pass
3390 3391 ImageStageLabelWrapper = _ImageStageLabelWrapper
3392 3393 -class _ImagingEnvironmentWrapper(BlitzObjectWrapper):
3394 pass
3395 3396 ImagingEnvironmentWrapper = _ImagingEnvironmentWrapper
3397 3398 -class _ImagingEnviromentWrapper (BlitzObjectWrapper):
3399 """ 3400 omero_model_ImagingEnvironmentI class wrapper extends BlitzObjectWrapper. 3401 """ 3402 _attrs = ('temperature', 3403 'airPressure', 3404 'humidity', 3405 'co2percent', 3406 'version') 3407
3408 - def __bstrap__ (self):
3409 self.OMERO_CLASS = 'ImagingEnvironment'
3410 3411 ImagingEnviromentWrapper = _ImagingEnviromentWrapper
3412 3413 -class _TransmittanceRangeWrapper (BlitzObjectWrapper):
3414 """ 3415 omero_model_TransmittanceRangeI class wrapper extends BlitzObjectWrapper. 3416 """ 3417 _attrs = ('cutIn', 3418 'cutOut', 3419 'cutInTolerance', 3420 'cutOutTolerance', 3421 'transmittance', 3422 'version') 3423
3424 - def __bstrap__ (self):
3425 self.OMERO_CLASS = 'TransmittanceRange'
3426 3427 TransmittanceRangeWrapper = _TransmittanceRangeWrapper
3428 3429 -class _DetectorSettingsWrapper (BlitzObjectWrapper):
3430 """ 3431 omero_model_DetectorSettingsI class wrapper extends BlitzObjectWrapper. 3432 """ 3433 _attrs = ('voltage', 3434 'gain', 3435 'offsetValue', 3436 'readOutRate', 3437 'binning', 3438 'detector|DetectorWrapper', 3439 'version') 3440
3441 - def __bstrap__ (self):
3442 self.OMERO_CLASS = 'DetectorSettings'
3443 3444 DetectorSettingsWrapper = _DetectorSettingsWrapper
3445 3446 -class _DetectorWrapper (BlitzObjectWrapper):
3447 """ 3448 omero_model_DetectorI class wrapper extends BlitzObjectWrapper. 3449 """ 3450 _attrs = ('manufacturer', 3451 'model', 3452 'serialNumber', 3453 'voltage', 3454 'gain', 3455 'offsetValue', 3456 'zoom', 3457 'amplificationGain', 3458 '#type;detectorType', 3459 'version') 3460
3461 - def __bstrap__ (self):
3462 self.OMERO_CLASS = 'Detector'
3463 3464 DetectorWrapper = _DetectorWrapper
3465 3466 -class _ObjectiveWrapper (BlitzObjectWrapper):
3467 """ 3468 omero_model_ObjectiveI class wrapper extends BlitzObjectWrapper. 3469 """ 3470 _attrs = ('manufacturer', 3471 'model', 3472 'serialNumber', 3473 'nominalMagnification', 3474 'calibratedMagnification', 3475 'lensNA', 3476 '#immersion', 3477 '#correction', 3478 'workingDistance', 3479 'iris', 3480 'version') 3481
3482 - def __bstrap__ (self):
3483 self.OMERO_CLASS = 'Objective'
3484 3485 ObjectiveWrapper = _ObjectiveWrapper
3486 3487 -class _ObjectiveSettingsWrapper (BlitzObjectWrapper):
3488 """ 3489 omero_model_ObjectiveSettingsI class wrapper extends BlitzObjectWrapper. 3490 """ 3491 _attrs = ('correctionCollar', 3492 'medium', 3493 'refractiveIndex', 3494 'objective|ObjectiveWrapper', 3495 'version') 3496
3497 - def __bstrap__ (self):
3498 self.OMERO_CLASS = 'ObjectiveSettings'
3499
3500 - def getObjective (self):
3501 rv = self.objective 3502 if self.objective is not None: 3503 rv = ObjectiveWrapper(self._conn, self.objective) 3504 if not self.objective.loaded: 3505 self.objective = rv._obj 3506 return rv
3507 3508 ObjectiveSettingsWrapper = _ObjectiveSettingsWrapper
3509 3510 3511 -class _FilterWrapper (BlitzObjectWrapper):
3512 """ 3513 omero_model_FilterI class wrapper extends BlitzObjectWrapper. 3514 """ 3515 _attrs = ('manufacturer', 3516 'model', 3517 'lotNumber', 3518 'filterWheel', 3519 'type;filterType', 3520 'transmittanceRange|TransmittanceRangeWrapper', 3521 'version') 3522
3523 - def __bstrap__ (self):
3524 self.OMERO_CLASS = 'Filter'
3525 3526 FilterWrapper = _FilterWrapper
3527 3528 -class _DichroicWrapper (BlitzObjectWrapper):
3529 """ 3530 omero_model_DichroicI class wrapper extends BlitzObjectWrapper. 3531 """ 3532 _attrs = ('manufacturer', 3533 'model', 3534 'lotNumber', 3535 'version') 3536
3537 - def __bstrap__ (self):
3538 self.OMERO_CLASS = 'Dichroic'
3539 3540 DichroicWrapper = _DichroicWrapper
3541 3542 -class _FilterSetWrapper (BlitzObjectWrapper):
3543 """ 3544 omero_model_FilterSetI class wrapper extends BlitzObjectWrapper. 3545 """ 3546 _attrs = ('manufacturer', 3547 'model', 3548 'lotNumber', 3549 #'exFilter|FilterWrapper', 3550 #'emFilter|FilterWrapper', 3551 'dichroic|DichroicWrapper', 3552 'version') 3553
3554 - def __bstrap__ (self):
3555 self.OMERO_CLASS = 'FilterSet'
3556
3557 - def copyEmissionFilters(self):
3558 pass
3559
3560 - def copyExcitationFilters(self):
3561 pass
3562 3563 FilterSetWrapper = _FilterSetWrapper
3564 3565 -class _OTFWrapper (BlitzObjectWrapper):
3566 """ 3567 omero_model_OTFI class wrapper extends BlitzObjectWrapper. 3568 """ 3569 _attrs = ('sizeX', 3570 'sizeY', 3571 'opticalAxisAveraged' 3572 'pixelsType', 3573 'path', 3574 'filterSet|FilterSetWrapper', 3575 'objective|ObjectiveWrapper', 3576 'version') 3577
3578 - def __bstrap__ (self):
3579 self.OMERO_CLASS = 'OTF'
3580 3581 OTFWrapper = _OTFWrapper
3582 3583 -class _LightSettingsWrapper (BlitzObjectWrapper):
3584 """ 3585 base Light Source class wrapper, extends BlitzObjectWrapper. 3586 """ 3587 _attrs = ('attenuation', 3588 'wavelength', 3589 'lightSource|LightSourceWrapper', 3590 'microbeamManipulation', 3591 'version') 3592
3593 - def __bstrap__ (self):
3594 self.OMERO_CLASS = 'LightSettings'
3595 3596 LightSettingsWrapper = _LightSettingsWrapper
3597 3598 -class _LightSourceWrapper (BlitzObjectWrapper):
3599 """ 3600 base Light Source class wrapper, extends BlitzObjectWrapper. 3601 """ 3602 _attrs = ('manufacturer', 3603 'model', 3604 'power', 3605 'serialNumber', 3606 '#type;lightsourceType', 3607 'version')
3608 3609 _LightSourceClasses = {}
3610 -def LightSourceWrapper (conn, obj, **kwargs):
3611 for k, v in _LightSourceClasses.items(): 3612 if isinstance(obj, k): 3613 return getattr(omero.gateway, v)(conn, obj, **kwargs) 3614 return None
3615
3616 -class _FilamentWrapper (_LightSourceWrapper):
3617 """ 3618 omero_model_ArcI class wrapper extends LightSourceWrapper. 3619 """ 3620
3621 - def __bstrap__ (self):
3622 super(self.__class__, self).__bstrap__() 3623 self.OMERO_CLASS = 'Filament'
3624 3625 FilamentWrapper = _FilamentWrapper 3626 _LightSourceClasses[omero.model.FilamentI] = 'FilamentWrapper'
3627 3628 -class _ArcWrapper (FilamentWrapper):
3629 """ 3630 omero_model_ArcI class wrapper extends FilamentWrapper. 3631 """
3632 - def __bstrap__ (self):
3633 super(self.__class__, self).__bstrap__() 3634 self.OMERO_CLASS = 'Arc'
3635 3636 ArcWrapper = _ArcWrapper 3637 _LightSourceClasses[omero.model.ArcI] = 'ArcWrapper'
3638 3639 -class _LaserWrapper (_LightSourceWrapper):
3640 """ 3641 omero_model_LaserI class wrapper extends LightSourceWrapper. 3642 """
3643 - def __bstrap__ (self):
3644 super(self.__class__, self).__bstrap__() 3645 self.OMERO_CLASS = 'Laser' 3646 self._attrs += ( 3647 '#laserMedium', 3648 'frequencyMultiplication', 3649 'tuneable', 3650 'pulse', 3651 'wavelength', 3652 'pockelCell', 3653 'pump', 3654 'repetitionRate')
3655 3656 LaserWrapper = _LaserWrapper 3657 _LightSourceClasses[omero.model.LaserI] = 'LaserWrapper'
3658 3659 -class _LightEmittingDiodeWrapper (_LightSourceWrapper):
3660 """ 3661 omero_model_LightEmittingDiodeI class wrapper extends LightSourceWrapper. 3662 """
3663 - def __bstrap__ (self):
3664 super(self.__class__, self).__bstrap__() 3665 self.OMERO_CLASS = 'LightEmittingDiode'
3666 3667 LightEmittingDiodeWrapper = _LightEmittingDiodeWrapper 3668 _LightSourceClasses[omero.model.LightEmittingDiodeI] = 'LightEmittingDiodeWrapper'
3669 3670 -class _MicroscopeWrapper (BlitzObjectWrapper):
3671 """ 3672 omero_model_MicroscopeI class wrapper extends BlitzObjectWrapper. 3673 """ 3674 _attrs = ('manufacturer', 3675 'model', 3676 'serialNumber', 3677 '#type;microscopeType', 3678 'version') 3679
3680 - def __bstrap__ (self):
3681 self.OMERO_CLASS = 'Microscope'
3682 3683 MicroscopeWrapper = _MicroscopeWrapper
3684 3685 -class _InstrumentWrapper (BlitzObjectWrapper):
3686 """ 3687 omero_model_InstrumentI class wrapper extends BlitzObjectWrapper. 3688 """ 3689 3690 # TODO: wrap version 3691 3692 _attrs = ('microscope|MicroscopeWrapper',) 3693
3694 - def __bstrap__ (self):
3695 self.OMERO_CLASS = 'Instrument'
3696
3697 - def getMicroscope (self):
3698 if self._obj.microscope is not None: 3699 return MicroscopeWrapper(self._conn, self._obj.microscope) 3700 return None
3701
3702 - def getDetectors (self):
3703 return [DetectorWrapper(self._conn, x) for x in self._detectorSeq]
3704
3705 - def getObjectives (self):
3706 return [ObjectiveWrapper(self._conn, x) for x in self._objectiveSeq]
3707
3708 - def getFilters (self):
3709 return [FilterWrapper(self._conn, x) for x in self._filterSeq]
3710
3711 - def getDichroics (self):
3712 return [DichroicWrapper(self._conn, x) for x in self._dichroicSeq]
3713
3714 - def getFilterSets (self):
3715 return [FilterSetWrapper(self._conn, x) for x in self._filterSetSeq]
3716
3717 - def getOTFs (self):
3718 return [OTFWrapper(self._conn, x) for x in self._otfSeq]
3719
3720 - def getLightSources (self):
3721 return [LightSourceWrapper(self._conn, x) for x in self._lightSourceSeq]
3722 3723
3724 - def simpleMarshal (self):
3725 if self._obj: 3726 rv = super(_InstrumentWrapper, self).simpleMarshal(parents=False) 3727 rv['detectors'] = [x.simpleMarshal() for x in self.getDetectors()] 3728 rv['objectives'] = [x.simpleMarshal() for x in self.getObjectives()] 3729 rv['filters'] = [x.simpleMarshal() for x in self.getFilters()] 3730 rv['dichroics'] = [x.simpleMarshal() for x in self.getDichroics()] 3731 rv['filterSets'] = [x.simpleMarshal() for x in self.getFilterSets()] 3732 rv['otfs'] = [x.simpleMarshal() for x in self.getOTFs()] 3733 rv['lightsources'] = [x.simpleMarshal() for x in self.getLightSources()] 3734 else: 3735 rv = {} 3736 return rv
3737 3738 InstrumentWrapper = _InstrumentWrapper 3739