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)
