def getProcessLogger(): '''Returns the default logger object.''' logger = IcePy.getProcessLogger() if isinstance(logger, Logger): return logger else: return LoggerI(logger)
def main(): sliceDir = Ice.getSliceDir() # Automatically add the slice dir. if not sliceDir is None: sys.argv.append('-I' + sliceDir) val = IcePy.compile(sys.argv) sys.exit(int(val))
def test_createLocalMirror(self): print('createLocalMirror') dataRoot = cvac.DirectoryPath( "corpus" ); corpusConfigFile = cvac.FilePath( dataRoot, "CvacCorpusTest.properties" ) corpus = self.cs.openCorpus( corpusConfigFile ) if not corpus: raise RuntimeError("could not open corpus from config file at '" +dataRoot.relativePath+"/"+corpusConfigFile.filename+"'") adapter = self.ic.createObjectAdapter("") ident = Ice.Identity() ident.name = IcePy.generateUUID() ident.category = "" # adapter.add( self, ident ) adapter.add( TestCorpusCallback(), ident ) adapter.activate() # adapter = self.ic.createObjectAdapter("CorpusServer") # adapter.add( TestCorpusCallback(), ic.stringToIdentity("CorpusServer:default -p 10011")) # adapter.activate() # receiver = cvac.CorpusCallbackPrx.uncheckedCast( # adapter.createProxy( self.ic.stringToIdentity("callbackReceiver"))) self.cs.createLocalMirror( corpus, ident ) if not self.cs.localMirrorExists( corpus ): raise RuntimeError( "could not create local mirror for", corpusConfigFile.filename )
def createProperties(args=None, defaults=None): '''Creates a new property set. The optional arguments represent an argument list (such as sys.argv) and a property set that supplies default values. You can invoke this function as follows: Ice.createProperties() Ice.createProperties(args) Ice.createProperties(defaults) Ice.createProperties(args, defaults) If you supply an argument list, the function removes those arguments from the list that were recognized by the Ice run time. ''' properties = IcePy.createProperties(args, defaults) return PropertiesI(properties)
def xtest_openCorpusLabelMe(self): print('openCorpusLabelMe') dataRoot = cvac.DirectoryPath( "corpus" ); corpusConfigFile = cvac.FilePath( dataRoot, "LabelMeCarsTest.properties" ) # corpusConfigFile = cvac.FilePath( dataRoot, "NpsVisionLabelMe.properties" ) corpus = self.cs.openCorpus( corpusConfigFile ) if not corpus: raise RuntimeError("could not open corpus from config file at '" +dataRoot.relativePath+"/"+corpusConfigFile.filename+"'"+"\n" +"Did you build CVAC with BUILD_LABELME_CORPUS=ON?") adapter = self.ic.createObjectAdapter("") ident = Ice.Identity() ident.name = IcePy.generateUUID() ident.category = "" adapter.add( TestCorpusCallback(), ident ) adapter.activate() self.cs.createLocalMirror( corpus, ident ) labels = self.cs.getDataSet( corpus ) if not labels: raise RuntimeError("could not obtain labels from Corpus '" +corpus.name+"'")
_M_IceGrid.ApplicationNotExistException = Ice.createTempClass() class ApplicationNotExistException(Ice.UserException): '''This exception is raised if an application does not exist.''' def __init__(self, name=''): self.name = name def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _ice_name = 'IceGrid::ApplicationNotExistException' _M_IceGrid._t_ApplicationNotExistException = IcePy.defineException( '::IceGrid::ApplicationNotExistException', ApplicationNotExistException, (), False, None, (('name', (), IcePy._t_string, False, 0), )) ApplicationNotExistException._ice_type = _M_IceGrid._t_ApplicationNotExistException _M_IceGrid.ApplicationNotExistException = ApplicationNotExistException del ApplicationNotExistException if 'ServerNotExistException' not in _M_IceGrid.__dict__: _M_IceGrid.ServerNotExistException = Ice.createTempClass() class ServerNotExistException(Ice.UserException): '''This exception is raised if a server does not exist.''' def __init__(self, id=''): self.id = id def __str__(self):
def ice_id(self): return '::IceMX::SessionMetrics' @staticmethod def ice_staticId(): return '::IceMX::SessionMetrics' def __str__(self): return IcePy.stringify(self, _M_IceMX._t_SessionMetrics) __repr__ = __str__ _M_IceMX._t_SessionMetrics = IcePy.defineValue('::IceMX::SessionMetrics', SessionMetrics, -1, (), False, False, _M_IceMX._t_Metrics, ( ('forwardedClient', (), IcePy._t_int, False, 0), ('forwardedServer', (), IcePy._t_int, False, 0), ('routingTableSize', (), IcePy._t_int, False, 0), ('queuedClient', (), IcePy._t_int, False, 0), ('queuedServer', (), IcePy._t_int, False, 0), ('overriddenClient', (), IcePy._t_int, False, 0), ('overriddenServer', (), IcePy._t_int, False, 0) )) SessionMetrics._ice_type = _M_IceMX._t_SessionMetrics _M_IceMX.SessionMetrics = SessionMetrics del SessionMetrics # End of module IceMX Ice.sliceChecksums["::IceMX::SessionMetrics"] = "221020be2c80301fb4dbb779e21b190"
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Details'): _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if not _M_omero.model.__dict__.has_key('QuantumDef'): _M_omero.model.QuantumDef = Ice.createTempClass() class QuantumDef(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _cdStart=None, _cdEnd=None, _bitResolution=None): if __builtin__.type(self) == _M_omero.model.QuantumDef: raise RuntimeError('omero.model.QuantumDef is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version self._cdStart = _cdStart self._cdEnd = _cdEnd self._bitResolution = _bitResolution def ice_ids(self, current=None):
def __str__(self): return IcePy.stringify(self, _M_bakrpc._t_BackupRPC)
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Project'): _M_omero.model._t_Project = IcePy.declareClass('::omero::model::Project') _M_omero.model._t_ProjectPrx = IcePy.declareProxy('::omero::model::Project') if not _M_omero.model.__dict__.has_key('Annotation'): _M_omero.model._t_Annotation = IcePy.declareClass('::omero::model::Annotation') _M_omero.model._t_AnnotationPrx = IcePy.declareProxy('::omero::model::Annotation') if not _M_omero.model.__dict__.has_key('Details'): _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if not _M_omero.model.__dict__.has_key('ProjectAnnotationLink'): _M_omero.model.ProjectAnnotationLink = Ice.createTempClass() class ProjectAnnotationLink(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _parent=None, _child=None): if __builtin__.type(self) == _M_omero.model.ProjectAnnotationLink:
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('PlateAcquisition'): _M_omero.model._t_PlateAcquisition = IcePy.declareClass('::omero::model::PlateAcquisition') _M_omero.model._t_PlateAcquisitionPrx = IcePy.declareProxy('::omero::model::PlateAcquisition') if not _M_omero.model.__dict__.has_key('Well'): _M_omero.model._t_Well = IcePy.declareClass('::omero::model::Well') _M_omero.model._t_WellPrx = IcePy.declareProxy('::omero::model::Well') if not _M_omero.model.__dict__.has_key('Image'): _M_omero.model._t_Image = IcePy.declareClass('::omero::model::Image') _M_omero.model._t_ImagePrx = IcePy.declareProxy('::omero::model::Image') if not _M_omero.model.__dict__.has_key('WellSampleAnnotationLink'): _M_omero.model._t_WellSampleAnnotationLink = IcePy.declareClass('::omero::model::WellSampleAnnotationLink') _M_omero.model._t_WellSampleAnnotationLinkPrx = IcePy.declareProxy('::omero::model::WellSampleAnnotationLink') if not _M_omero.model.__dict__.has_key('Annotation'):
def __str__(self): return IcePy.stringify(self, _M_Conector._t_ConfirmarMelodiaDisp)
# # Generated from file `MediaFile.ice' # # Warning: do not edit this file. # # </auto-generated> # import Ice, IcePy # Start of module MediaFile _M_MediaFile = Ice.openModule('MediaFile') __name__ = 'MediaFile' if '_t_ByteString' not in _M_MediaFile.__dict__: _M_MediaFile._t_ByteString = IcePy.defineSequence('::MediaFile::ByteString', (), IcePy._t_byte) if '_t_FFMPEGParamsMap' not in _M_MediaFile.__dict__: _M_MediaFile._t_FFMPEGParamsMap = IcePy.defineDictionary('::MediaFile::FFMPEGParamsMap', (), IcePy._t_string, IcePy._t_string) if 'FileTransfer' not in _M_MediaFile.__dict__: _M_MediaFile.FileTransfer = Ice.createTempClass() class FileTransfer(Ice.Object): def __init__(self): if Ice.getType(self) == _M_MediaFile.FileTransfer: raise RuntimeError('MediaFile.FileTransfer is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::MediaFile::FileTransfer') def ice_id(self, current=None):
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_Frequency)
# # Generated from file `Conector.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module Conector _M_Conector = Ice.openModule('Conector') __name__ = 'Conector' _M_Conector._t_Actuador = IcePy.defineValue('::Conector::Actuador', Ice.Value, -1, (), False, True, None, ()) if 'ActuadorPrx' not in _M_Conector.__dict__: _M_Conector.ActuadorPrx = Ice.createTempClass() class ActuadorPrx(Ice.ObjectPrx): def actuart(self, melodia, context=None): return _M_Conector.Actuador._op_actuart.invoke( self, ((melodia, ), context)) def actuartAsync(self, melodia, context=None): return _M_Conector.Actuador._op_actuart.invokeAsync( self, ((melodia, ), context)) def begin_actuart(self, melodia,
return _M_omero.model.FrequencyPrx.ice_checkedCast( proxy, '::omero::model::Frequency', facetOrCtx, _ctx) checkedCast = staticmethod(checkedCast) def uncheckedCast(proxy, facet=None): return _M_omero.model.FrequencyPrx.ice_uncheckedCast(proxy, facet) uncheckedCast = staticmethod(uncheckedCast) def ice_staticId(): return '::omero::model::Frequency' ice_staticId = staticmethod(ice_staticId) _M_omero.model._t_FrequencyPrx = IcePy.defineProxy( '::omero::model::Frequency', FrequencyPrx) _M_omero.model._t_Frequency = IcePy.defineClass( '::omero::model::Frequency', Frequency, -1, (), True, False, None, (), (('_value', (), IcePy._t_double, False, 0), ('_unit', (), _M_omero.model.enums._t_UnitsFrequency, False, 0))) Frequency._ice_type = _M_omero.model._t_Frequency Frequency._op_getValue = IcePy.Operation( 'getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_double, False, 0), ()) Frequency._op_setValue = IcePy.Operation( 'setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_double, False, 0), ), (), None, ()) Frequency._op_getUnit = IcePy.Operation( 'getUnit', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
# Included module omero _M_omero = Ice.openModule('omero') # Included module Ice _M_Ice = Ice.openModule('Ice') # Start of module omero __name__ = 'omero' # Start of module omero.sys _M_omero.sys = Ice.openModule('omero.sys') __name__ = 'omero.sys' if '_t_LongList' not in _M_omero.sys.__dict__: _M_omero.sys._t_LongList = IcePy.defineSequence('::omero::sys::LongList', (), IcePy._t_long) if '_t_IntList' not in _M_omero.sys.__dict__: _M_omero.sys._t_IntList = IcePy.defineSequence('::omero::sys::IntList', (), IcePy._t_int) if '_t_CountMap' not in _M_omero.sys.__dict__: _M_omero.sys._t_CountMap = IcePy.defineDictionary('::omero::sys::CountMap', (), IcePy._t_long, IcePy._t_long) if '_t_ParamMap' not in _M_omero.sys.__dict__: _M_omero.sys._t_ParamMap = IcePy.defineDictionary('::omero::sys::ParamMap', (), IcePy._t_string, _M_omero._t_RType) if '_t_IdByteMap' not in _M_omero.sys.__dict__: _M_omero.sys._t_IdByteMap = IcePy.defineDictionary('::omero::sys::IdByteMap', (), IcePy._t_long, _M_Ice._t_ByteSeq) if 'EventContext' not in _M_omero.sys.__dict__: _M_omero.sys._t_EventContext = IcePy.declareClass('::omero::sys::EventContext')
def __str__(self): return IcePy.stringify(self, _M_IceMX._t_SessionMetrics)
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_JobStatus)
def __str__(self): return IcePy.stringify(self, _M_Conector._t_ActuadorDisp)
return NotImplemented def __ge__(self, other): if isinstance(other, _M_WorldStateTopic.Position): return self.x >= other.x or self.y >= other.y elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_WorldStateTopic._t_Position) __repr__ = __str__ _M_WorldStateTopic._t_Position = IcePy.defineStruct('::WorldStateTopic::Position', Position, (), ( ('x', (), IcePy._t_float), ('y', (), IcePy._t_float) )) _M_WorldStateTopic.Position = Position del Position if not _M_WorldStateTopic.__dict__.has_key('Ball'): _M_WorldStateTopic.Ball = Ice.createTempClass() class Ball(object): def __init__(self, pos=Ice._struct_marker): if pos is Ice._struct_marker: self.pos = _M_WorldStateTopic.Position() else: self.pos = pos def __hash__(self):
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if 'Temperature' not in _M_omero.model.__dict__: _M_omero.model._t_Temperature = IcePy.declareClass('::omero::model::Temperature') _M_omero.model._t_TemperaturePrx = IcePy.declareProxy('::omero::model::Temperature') if 'Pressure' not in _M_omero.model.__dict__: _M_omero.model._t_Pressure = IcePy.declareClass('::omero::model::Pressure') _M_omero.model._t_PressurePrx = IcePy.declareProxy('::omero::model::Pressure') if 'Details' not in _M_omero.model.__dict__: _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if 'ImagingEnvironment' not in _M_omero.model.__dict__: _M_omero.model.ImagingEnvironment = Ice.createTempClass() class ImagingEnvironment(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _temperature=None, _airPressure=None, _humidity=None, _co2percent=None, _map=None): if Ice.getType(self) == _M_omero.model.ImagingEnvironment:
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Details'): _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if not _M_omero.model.__dict__.has_key('StatsInfo'): _M_omero.model.StatsInfo = Ice.createTempClass() class StatsInfo(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _globalMin=None, _globalMax=None): if __builtin__.type(self) == _M_omero.model.StatsInfo: raise RuntimeError('omero.model.StatsInfo is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version self._globalMin = _globalMin self._globalMax = _globalMax def ice_ids(self, current=None): return ('::Ice::Object', '::omero::model::IObject', '::omero::model::StatsInfo')
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_ImagingEnvironment)
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('LightSource'): _M_omero.model._t_LightSource = IcePy.declareClass('::omero::model::LightSource') _M_omero.model._t_LightSourcePrx = IcePy.declareProxy('::omero::model::LightSource') if not _M_omero.model.__dict__.has_key('MicrobeamManipulation'): _M_omero.model._t_MicrobeamManipulation = IcePy.declareClass('::omero::model::MicrobeamManipulation') _M_omero.model._t_MicrobeamManipulationPrx = IcePy.declareProxy('::omero::model::MicrobeamManipulation') if not _M_omero.model.__dict__.has_key('Details'): _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if not _M_omero.model.__dict__.has_key('LightSettings'): _M_omero.model.LightSettings = Ice.createTempClass() class LightSettings(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _attenuation=None, _wavelength=None, _lightSource=None, _microbeamManipulation=None): if __builtin__.type(self) == _M_omero.model.LightSettings:
9: UnitsElectricPotential.DECAVOLT, 10: UnitsElectricPotential.VOLT, 11: UnitsElectricPotential.DECIVOLT, 12: UnitsElectricPotential.CENTIVOLT, 13: UnitsElectricPotential.MILLIVOLT, 14: UnitsElectricPotential.MICROVOLT, 15: UnitsElectricPotential.NANOVOLT, 16: UnitsElectricPotential.PICOVOLT, 17: UnitsElectricPotential.FEMTOVOLT, 18: UnitsElectricPotential.ATTOVOLT, 19: UnitsElectricPotential.ZEPTOVOLT, 20: UnitsElectricPotential.YOCTOVOLT } _M_omero.model.enums._t_UnitsElectricPotential = IcePy.defineEnum( '::omero::model::enums::UnitsElectricPotential', UnitsElectricPotential, (), UnitsElectricPotential._enumerators) _M_omero.model.enums.UnitsElectricPotential = UnitsElectricPotential del UnitsElectricPotential if 'UnitsFrequency' not in _M_omero.model.enums.__dict__: _M_omero.model.enums.UnitsFrequency = Ice.createTempClass() class UnitsFrequency(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n]
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Gender'): _M_omero.model._t_Gender = IcePy.declareClass('::omero::model::Gender') _M_omero.model._t_GenderPrx = IcePy.declareProxy('::omero::model::Gender') if not _M_omero.model.__dict__.has_key('Individual'): _M_omero.model._t_Individual = IcePy.declareClass('::omero::model::Individual') _M_omero.model._t_IndividualPrx = IcePy.declareProxy('::omero::model::Individual') if not _M_omero.model.__dict__.has_key('Action'): _M_omero.model._t_Action = IcePy.declareClass('::omero::model::Action') _M_omero.model._t_ActionPrx = IcePy.declareProxy('::omero::model::Action') if not _M_omero.model.__dict__.has_key('ActionOnAction'): _M_omero.model._t_ActionOnAction = IcePy.declareClass('::omero::model::ActionOnAction') _M_omero.model._t_ActionOnActionPrx = IcePy.declareProxy('::omero::model::ActionOnAction') if not _M_omero.model.__dict__.has_key('Details'):
def __str__(self): return IcePy.stringify(self, _M_RemoteAi._t_AiInformation)
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Screen'): _M_omero.model._t_Screen = IcePy.declareClass('::omero::model::Screen') _M_omero.model._t_ScreenPrx = IcePy.declareProxy('::omero::model::Screen') if not _M_omero.model.__dict__.has_key('WellReagentLink'): _M_omero.model._t_WellReagentLink = IcePy.declareClass('::omero::model::WellReagentLink') _M_omero.model._t_WellReagentLinkPrx = IcePy.declareProxy('::omero::model::WellReagentLink') if not _M_omero.model.__dict__.has_key('Well'): _M_omero.model._t_Well = IcePy.declareClass('::omero::model::Well') _M_omero.model._t_WellPrx = IcePy.declareProxy('::omero::model::Well') if not _M_omero.model.__dict__.has_key('ReagentAnnotationLink'): _M_omero.model._t_ReagentAnnotationLink = IcePy.declareClass('::omero::model::ReagentAnnotationLink') _M_omero.model._t_ReagentAnnotationLinkPrx = IcePy.declareProxy('::omero::model::ReagentAnnotationLink') if not _M_omero.model.__dict__.has_key('Annotation'):
def __str__(self): return IcePy.stringify(self, _M_omero.api._t_ITypes)
return -1 elif self.name > other.name: return 1 if self.eventType < other.eventType: return -1 elif self.eventType > other.eventType: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_RemoteAi._t_StateEvent) __repr__ = __str__ _M_RemoteAi._t_StateEvent = IcePy.defineStruct( '::RemoteAi::StateEvent', StateEvent, (), (('timeStamp', (), IcePy._t_long), ('type', (), IcePy._t_string), ('name', (), IcePy._t_string), ('eventType', (), IcePy._t_string))) _M_RemoteAi.StateEvent = StateEvent del StateEvent if not _M_RemoteAi.__dict__.has_key('_t_StateList'): _M_RemoteAi._t_StateList = IcePy.defineSequence('::RemoteAi::StateList', (), _M_RemoteAi._t_StateEvent) if not _M_RemoteAi.__dict__.has_key('AiInformation'): _M_RemoteAi.AiInformation = Ice.createTempClass() class AiInformation(Ice.Object): def __init__(self):
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_ActionOnAction)
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if 'FilterSet' not in _M_omero.model.__dict__: _M_omero.model._t_FilterSet = IcePy.declareClass('::omero::model::FilterSet') _M_omero.model._t_FilterSetPrx = IcePy.declareProxy('::omero::model::FilterSet') if 'Filter' not in _M_omero.model.__dict__: _M_omero.model._t_Filter = IcePy.declareClass('::omero::model::Filter') _M_omero.model._t_FilterPrx = IcePy.declareProxy('::omero::model::Filter') if 'Details' not in _M_omero.model.__dict__: _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if 'FilterSetExcitationFilterLink' not in _M_omero.model.__dict__: _M_omero.model.FilterSetExcitationFilterLink = Ice.createTempClass() class FilterSetExcitationFilterLink(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _parent=None, _child=None): if Ice.getType(self) == _M_omero.model.FilterSetExcitationFilterLink:
def __str__(self): return IcePy.stringify(self, _M_RemoteAi._t_StateEvent)
def end_resetEnumerations(self, _r): return _M_omero.api.ITypes._op_resetEnumerations.end(self, _r) def resetEnumerations_async(self, _cb, enumClass, _ctx=None): return _M_omero.api.ITypes._op_resetEnumerations.invokeAsync(self, (_cb, (enumClass, ), _ctx)) def checkedCast(proxy, facetOrCtx=None, _ctx=None): return _M_omero.api.ITypesPrx.ice_checkedCast(proxy, '::omero::api::ITypes', facetOrCtx, _ctx) checkedCast = staticmethod(checkedCast) def uncheckedCast(proxy, facet=None): return _M_omero.api.ITypesPrx.ice_uncheckedCast(proxy, facet) uncheckedCast = staticmethod(uncheckedCast) _M_omero.api._t_ITypesPrx = IcePy.defineProxy('::omero::api::ITypes', ITypesPrx) _M_omero.api._t_ITypes = IcePy.defineClass('::omero::api::ITypes', ITypes, (), True, None, (_M_omero.api._t_ServiceInterface,), ()) ITypes._ice_type = _M_omero.api._t_ITypes ITypes._op_createEnumeration = IcePy.Operation('createEnumeration', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,)) ITypes._op_getEnumeration = IcePy.Operation('getEnumeration', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (((), IcePy._t_string), ((), IcePy._t_string)), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,)) ITypes._op_allEnumerations = IcePy.Operation('allEnumerations', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (((), IcePy._t_string),), (), _M_omero.api._t_IObjectList, (_M_omero._t_ServerError,)) ITypes._op_updateEnumeration = IcePy.Operation('updateEnumeration', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,)) ITypes._op_updateEnumerations = IcePy.Operation('updateEnumerations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.api._t_IObjectList),), (), None, (_M_omero._t_ServerError,)) ITypes._op_deleteEnumeration = IcePy.Operation('deleteEnumeration', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), None, (_M_omero._t_ServerError,)) ITypes._op_getEnumerationTypes = IcePy.Operation('getEnumerationTypes', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), _M_omero.api._t_StringSet, (_M_omero._t_ServerError,)) ITypes._op_getAnnotationTypes = IcePy.Operation('getAnnotationTypes', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), _M_omero.api._t_StringSet, (_M_omero._t_ServerError,)) ITypes._op_getEnumerationsWithEntries = IcePy.Operation('getEnumerationsWithEntries', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), _M_omero.api._t_IObjectListMap, (_M_omero._t_ServerError,)) ITypes._op_getOriginalEnumerations = IcePy.Operation('getOriginalEnumerations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (), (), _M_omero.api._t_IObjectList, (_M_omero._t_ServerError,)) ITypes._op_resetEnumerations = IcePy.Operation('resetEnumerations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), IcePy._t_string),), (), None, (_M_omero._t_ServerError,))
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_FilterSetExcitationFilterLink)
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Action'): _M_omero.model._t_Action = IcePy.declareClass('::omero::model::Action') _M_omero.model._t_ActionPrx = IcePy.declareProxy('::omero::model::Action') if not _M_omero.model.__dict__.has_key('ActionSetup'): _M_omero.model._t_ActionSetup = IcePy.declareClass('::omero::model::ActionSetup') _M_omero.model._t_ActionSetupPrx = IcePy.declareProxy('::omero::model::ActionSetup') if not _M_omero.model.__dict__.has_key('Device'): _M_omero.model._t_Device = IcePy.declareClass('::omero::model::Device') _M_omero.model._t_DevicePrx = IcePy.declareProxy('::omero::model::Device') if not _M_omero.model.__dict__.has_key('ActionCategory'): _M_omero.model._t_ActionCategory = IcePy.declareClass('::omero::model::ActionCategory') _M_omero.model._t_ActionCategoryPrx = IcePy.declareProxy('::omero::model::ActionCategory') if not _M_omero.model.__dict__.has_key('Study'):
Arguments: facet The name of the Admin facet. Returns: The servant associated with this Admin facet, or null if no facet is registered with the given name.''' pass def findAllAdminFacets(self): '''Returns a map of all facets of the Admin object. Returns: A collection containing all the facet names and servants of the Admin object.''' pass def __str__(self): return IcePy.stringify(self, _M_Ice._t_Communicator) __repr__ = __str__ _M_Ice._t_Communicator = IcePy.defineClass('::Ice::Communicator', Communicator, -1, (), True, False, None, (), ()) Communicator._ice_type = _M_Ice._t_Communicator _M_Ice.Communicator = Communicator del Communicator # End of module Ice
_M_omero.model.enums.JobStatusRunning = "Running" _M_omero.model.enums.JobStatusError = "Error" _M_omero.model.enums.JobStatusWaiting = "Waiting" _M_omero.model.enums.JobStatusFinished = "Finished" _M_omero.model.enums.JobStatusCancelled = "Cancelled" # End of module omero.model.enums __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('Details'): _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if not _M_omero.model.__dict__.has_key('JobStatus'): _M_omero.model.JobStatus = Ice.createTempClass() class JobStatus(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _value=None): if __builtin__.type(self) == _M_omero.model.JobStatus: raise RuntimeError('omero.model.JobStatus is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._value = _value def ice_ids(self, current=None): return ('::Ice::Object', '::omero::model::IObject', '::omero::model::JobStatus') def ice_id(self, current=None):
def __str__(self): return IcePy.stringify(self, _M_Ice._t_Communicator)
_M_Ice = Ice.openModule('Ice') # Included module omero.sys _M_omero.sys = Ice.openModule('omero.sys') # Included module omero.api _M_omero.api = Ice.openModule('omero.api') # Start of module omero __name__ = 'omero' # Start of module omero.model __name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('FlowCell'): _M_omero.model._t_FlowCell = IcePy.declareClass('::omero::model::FlowCell') _M_omero.model._t_FlowCellPrx = IcePy.declareProxy('::omero::model::FlowCell') if not _M_omero.model.__dict__.has_key('ContainerStatus'): _M_omero.model._t_ContainerStatus = IcePy.declareClass('::omero::model::ContainerStatus') _M_omero.model._t_ContainerStatusPrx = IcePy.declareProxy('::omero::model::ContainerStatus') if not _M_omero.model.__dict__.has_key('Action'): _M_omero.model._t_Action = IcePy.declareClass('::omero::model::Action') _M_omero.model._t_ActionPrx = IcePy.declareProxy('::omero::model::Action') if not _M_omero.model.__dict__.has_key('Details'): _M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details') _M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details') if not _M_omero.model.__dict__.has_key('Lane'):
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_jderobot._t_Time) __repr__ = __str__ _M_jderobot._t_Time = IcePy.defineStruct('::jderobot::Time', Time, (), (('seconds', (), IcePy._t_long), ('useconds', (), IcePy._t_long))) _M_jderobot.Time = Time del Time # End of module jderobot # Start of module jderobot __name__ = 'jderobot' if 'JderobotException' not in _M_jderobot.__dict__: _M_jderobot.JderobotException = Ice.createTempClass() class JderobotException(Ice.UserException): def __init__(self, what=''):
def __str__(self): return IcePy.stringify(self, _M_WorldStateTopic._t_Position)
def __str__(self): return IcePy.stringify(self, _M_jderobot._t_Time)
def __str__(self): return IcePy.stringify(self, _M_MediaFile._t_FileTransfer)
def __str__(self): return IcePy.stringifyException(self)
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_StatsInfo)
def __str__(self): return IcePy.stringify(self, _M_jderobot._t_PTMotors)
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_ProjectAnnotationLink)
""" Create or update a key/value entry in the underlying context. Arguments: key -- The key. value -- The value. Returns: The previous value associated with the key, if any. """ raise NotImplementedError("method 'put' not implemented") def remove(self, key): """ Remove the entry for the given key in the underlying context. Arguments: key -- The key. Returns: The value associated with the key, if any. """ raise NotImplementedError("method 'remove' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice._t_ImplicitContext) __repr__ = __str__ _M_Ice._t_ImplicitContext = IcePy.defineValue('::Ice::ImplicitContext', ImplicitContext, -1, (), False, True, None, ()) ImplicitContext._ice_type = _M_Ice._t_ImplicitContext _M_Ice.ImplicitContext = ImplicitContext del ImplicitContext # End of module Ice
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_LightSettings)
def __str__(self): return IcePy.stringify(self, _M_Ice._t_ImplicitContext)
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_WellSample)
ice = Ice.initialize(idata) prx = ice.stringToProxy(prxstr) print "Done" slicedir = Ice.getSliceDir() if not slicedir: # Some platforms incorrectly return None as the slice path # try to work around this for the known ones. slicedir = ["-I/usr/share/Ice/slice", "-I/usr/share/slice"] else: slicedir = ['-I' + slicedir] try: print "Trying to retrieve slice dynamically from server...", slice = IcePy.Operation('getSlice', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), IcePy._t_string, ()).invoke(prx, ((), None)) (dynslicefiledesc, dynslicefilepath) = tempfile.mkstemp(suffix='.ice') dynslicefile = os.fdopen(dynslicefiledesc, 'w') dynslicefile.write(slice) dynslicefile.flush() Ice.loadSlice('', slicedir + [dynslicefilepath]) dynslicefile.close() os.remove(dynslicefilepath) print "Success" except Exception, e: print "Failed" print str(e) while not os.path.exists(slicefile): slicefile = raw_input("Path to slicefile: ")
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_Individual)
# This copy of Ice is licensed to you under the terms described in the # ICE_LICENSE file included in this distribution. # # ********************************************************************** # Ice version 3.4.1 # <auto-generated> # # Generated from file `LocatorF.ice' # # Warning: do not edit this file. # # </auto-generated> import Ice, IcePy, __builtin__ # Start of module Ice _M_Ice = Ice.openModule('Ice') __name__ = 'Ice' if not _M_Ice.__dict__.has_key('Locator'): _M_Ice._t_Locator = IcePy.declareClass('::Ice::Locator') _M_Ice._t_LocatorPrx = IcePy.declareProxy('::Ice::Locator') if not _M_Ice.__dict__.has_key('LocatorRegistry'): _M_Ice._t_LocatorRegistry = IcePy.declareClass('::Ice::LocatorRegistry') _M_Ice._t_LocatorRegistryPrx = IcePy.declareProxy('::Ice::LocatorRegistry') # End of module Ice
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_QuantumDef)
to load a service executable. Members: reason -- The reason for the failure. """ def __init__(self, reason=''): self.reason = reason def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _ice_id = '::IceBox::FailureException' _M_IceBox._t_FailureException = IcePy.defineException( '::IceBox::FailureException', FailureException, (), False, None, (('reason', (), IcePy._t_string, False, 0), )) FailureException._ice_type = _M_IceBox._t_FailureException _M_IceBox.FailureException = FailureException del FailureException if 'AlreadyStartedException' not in _M_IceBox.__dict__: _M_IceBox.AlreadyStartedException = Ice.createTempClass() class AlreadyStartedException(Ice.UserException): """ This exception is thrown if an attempt is made to start an already-started service. """ def __init__(self):
def __str__(self): return IcePy.stringify(self, _M_omero.model._t_Reagent)
def __str__(self): return IcePy.stringify(self, _M_kvm4remote._t_KVM)