# Included module Glacier2 _M_Glacier2 = Ice.openModule('Glacier2') # Included module omero _M_omero = Ice.openModule('omero') # Start of module omero __name__ = 'omero' # Start of module omero.romio _M_omero.romio = Ice.openModule('omero.romio') __name__ = 'omero.romio' _M_omero.romio.__doc__ = '''Primitives for working with binary data.''' if not _M_omero.romio.__dict__.has_key('_t_RGBBands'): _M_omero.romio._t_RGBBands = IcePy.defineSequence('::omero::romio::RGBBands', (), _M_Ice._t_ByteSeq) _M_omero.romio.RedBand = 0 _M_omero.romio.GreenBand = 1 _M_omero.romio.BlueBand = 2 if not _M_omero.romio.__dict__.has_key('RGBBuffer'): _M_omero.romio.RGBBuffer = Ice.createTempClass() class RGBBuffer(Ice.Object): def __init__(self, bands=None, sizeX1=0, sizeX2=0): self.bands = bands self.sizeX1 = sizeX1 self.sizeX2 = sizeX2
'::omero::metadatastore::IObjectContainer', IObjectContainer, -1, (), False, False, None, (), (('LSID', (), IcePy._t_string, False, 0), ('indexes', (), _M_omero.api._t_StringIntMap, False, 0), ('sourceObject', (), _M_omero.model._t_IObject, False, 0))) IObjectContainer._ice_type = _M_omero.metadatastore._t_IObjectContainer _M_omero.metadatastore.IObjectContainer = IObjectContainer del IObjectContainer _M_omero.metadatastore.IObjectContainerPrx = IObjectContainerPrx del IObjectContainerPrx if '_t_IObjectContainerArray' not in _M_omero.metadatastore.__dict__: _M_omero.metadatastore._t_IObjectContainerArray = IcePy.defineSequence( '::omero::metadatastore::IObjectContainerArray', (), _M_omero.metadatastore._t_IObjectContainer) # End of module omero.metadatastore __name__ = 'omero' # Start of module omero.api __name__ = 'omero.api' if 'MetadataStore' not in _M_omero.api.__dict__: _M_omero.api.MetadataStore = Ice.createTempClass() class MetadataStore(_M_omero.api.StatefulServiceInterface): """ Server-side interface for import.
_M_FS._t_Example = IcePy.defineClass('::FS::Example', Example, (), False, None, (), (('apilevel', (), IcePy._t_short), )) Example._ice_type = _M_FS._t_Example _M_FS.Example = Example del Example _M_FS.ExamplePrx = ExamplePrx del ExamplePrx _M_FS._lambda = 0 if not _M_FS.__dict__.has_key('_t_StringSeq'): _M_FS._t_StringSeq = IcePy.defineSequence('::FS::StringSeq', (), IcePy._t_string) if not _M_FS.__dict__.has_key('_t_StringDict'): _M_FS._t_StringDict = IcePy.defineDictionary('::FS::StringDict', (), IcePy._t_string, IcePy._t_string) if not _M_FS.__dict__.has_key('mystruct'): _M_FS.mystruct = Ice.createTempClass() class mystruct(object): def __init__(self, mytype=0, bo=False, by=0, sh=0,
from sys import version_info as _version_info_ import Ice, IcePy # Start of module Ice _M_Ice = Ice.openModule('Ice') __name__ = 'Ice' if 'EndpointInfo' not in _M_Ice.__dict__: _M_Ice._t_EndpointInfo = IcePy.declareValue('::Ice::EndpointInfo') if 'IPEndpointInfo' not in _M_Ice.__dict__: _M_Ice._t_IPEndpointInfo = IcePy.declareValue('::Ice::IPEndpointInfo') if 'TCPEndpointInfo' not in _M_Ice.__dict__: _M_Ice._t_TCPEndpointInfo = IcePy.declareValue('::Ice::TCPEndpointInfo') if 'UDPEndpointInfo' not in _M_Ice.__dict__: _M_Ice._t_UDPEndpointInfo = IcePy.declareValue('::Ice::UDPEndpointInfo') if 'WSEndpointInfo' not in _M_Ice.__dict__: _M_Ice._t_WSEndpointInfo = IcePy.declareValue('::Ice::WSEndpointInfo') if 'Endpoint' not in _M_Ice.__dict__: _M_Ice._t_Endpoint = IcePy.declareValue('::Ice::Endpoint') if '_t_EndpointSeq' not in _M_Ice.__dict__: _M_Ice._t_EndpointSeq = IcePy.defineSequence('::Ice::EndpointSeq', (), _M_Ice._t_Endpoint) # End of module Ice
def __str__(self): return IcePy.stringify(self, _M_MetaServer._t_Song) __repr__ = __str__ _M_MetaServer._t_Song = IcePy.defineStruct( '::MetaServer::Song', Song, (), (('name', (), IcePy._t_string), ('author', (), IcePy._t_string), ('album', (), IcePy._t_string), ('path', (), IcePy._t_string))) _M_MetaServer.Song = Song del Song if '_t_SongSeq' not in _M_MetaServer.__dict__: _M_MetaServer._t_SongSeq = IcePy.defineSequence('::MetaServer::SongSeq', (), _M_MetaServer._t_Song) _M_MetaServer._t_IMetaServer = IcePy.defineValue('::MetaServer::IMetaServer', Ice.Value, -1, (), False, True, None, ()) if 'IMetaServerPrx' not in _M_MetaServer.__dict__: _M_MetaServer.IMetaServerPrx = Ice.createTempClass() class IMetaServerPrx(Ice.ObjectPrx): def searchMusic(self, name, author, album, context=None): return _M_MetaServer.IMetaServer._op_searchMusic.invoke( self, ((name, author, album), context)) def searchMusicAsync(self, name, author, album, context=None): return _M_MetaServer.IMetaServer._op_searchMusic.invokeAsync(
# Generated from file `Filecenter.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module filecenter _M_filecenter = Ice.openModule('filecenter') __name__ = 'filecenter' if '_t_Bytes' not in _M_filecenter.__dict__: _M_filecenter._t_Bytes = IcePy.defineSequence('::filecenter::Bytes', (), IcePy._t_byte) if '_t_ExtInfo' not in _M_filecenter.__dict__: _M_filecenter._t_ExtInfo = IcePy.defineDictionary('::filecenter::ExtInfo', (), IcePy._t_string, IcePy._t_string) if 'FileInfo' not in _M_filecenter.__dict__: _M_filecenter.FileInfo = Ice.createTempClass() class FileInfo(object): def __init__(self, creattime=0, updatetime=0, filesize=0, filescore=0,
_M_jderobot._t_SubscriptionPushFailedException = IcePy.defineException( '::jderobot::SubscriptionPushFailedException', SubscriptionPushFailedException, (), False, _M_jderobot._t_JderobotException, ()) SubscriptionPushFailedException._ice_type = _M_jderobot._t_SubscriptionPushFailedException _M_jderobot.SubscriptionPushFailedException = SubscriptionPushFailedException del SubscriptionPushFailedException # End of module jderobot # Start of module jderobot __name__ = 'jderobot' if '_t_ByteSeq' not in _M_jderobot.__dict__: _M_jderobot._t_ByteSeq = IcePy.defineSequence('::jderobot::ByteSeq', (), IcePy._t_byte) if '_t_IntSeq' not in _M_jderobot.__dict__: _M_jderobot._t_IntSeq = IcePy.defineSequence('::jderobot::IntSeq', (), IcePy._t_int) if '_t_seqFloat' not in _M_jderobot.__dict__: _M_jderobot._t_seqFloat = IcePy.defineSequence('::jderobot::seqFloat', (), IcePy._t_float) # End of module jderobot # Start of module jderobot __name__ = 'jderobot' # End of module jderobot
_M_omero.model._t_PixelsPrx = IcePy.declareProxy('::omero::model::Pixels') if not _M_omero.model.__dict__.has_key('OriginalFileAnnotationLink'): _M_omero.model._t_OriginalFileAnnotationLink = IcePy.declareClass('::omero::model::OriginalFileAnnotationLink') _M_omero.model._t_OriginalFileAnnotationLinkPrx = IcePy.declareProxy('::omero::model::OriginalFileAnnotationLink') 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('_t_OriginalFilePixelsFileMapsSeq'): _M_omero.model._t_OriginalFilePixelsFileMapsSeq = IcePy.defineSequence('::omero::model::OriginalFilePixelsFileMapsSeq', (), _M_omero.model._t_PixelsOriginalFileMap) if not _M_omero.model.__dict__.has_key('_t_OriginalFileLinkedPixelsSeq'): _M_omero.model._t_OriginalFileLinkedPixelsSeq = IcePy.defineSequence('::omero::model::OriginalFileLinkedPixelsSeq', (), _M_omero.model._t_Pixels) if not _M_omero.model.__dict__.has_key('_t_OriginalFileAnnotationLinksSeq'): _M_omero.model._t_OriginalFileAnnotationLinksSeq = IcePy.defineSequence('::omero::model::OriginalFileAnnotationLinksSeq', (), _M_omero.model._t_OriginalFileAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_OriginalFileLinkedAnnotationSeq'): _M_omero.model._t_OriginalFileLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::OriginalFileLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('OriginalFile'): _M_omero.model.OriginalFile = Ice.createTempClass() class OriginalFile(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _pixelsFileMapsSeq=None, _pixelsFileMapsLoaded=False, _pixelsFileMapsCountPerOwner=None, _path=None, _size=None, _atime=None, _mtime=None, _ctime=None, _sha1=None, _mimetype=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _name=None): if __builtin__.type(self) == _M_omero.model.OriginalFile:
def ice_name(self): return 'MyUtil::NoSuchPropertyException' def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _M_MyUtil._t_NoSuchPropertyException = IcePy.defineException('::MyUtil::NoSuchPropertyException', NoSuchPropertyException, (), _M_MyUtil._t_MceException, ()) NoSuchPropertyException.ice_type = _M_MyUtil._t_NoSuchPropertyException _M_MyUtil.NoSuchPropertyException = NoSuchPropertyException del NoSuchPropertyException if not _M_MyUtil.__dict__.has_key('_t_ByteSeq'): _M_MyUtil._t_ByteSeq = IcePy.defineSequence('::MyUtil::ByteSeq', (), IcePy._t_byte) if not _M_MyUtil.__dict__.has_key('_t_IntSeq'): _M_MyUtil._t_IntSeq = IcePy.defineSequence('::MyUtil::IntSeq', (), IcePy._t_int) if not _M_MyUtil.__dict__.has_key('_t_IntList'): _M_MyUtil._t_IntList = IcePy.defineSequence('::MyUtil::IntList', (), IcePy._t_int) if not _M_MyUtil.__dict__.has_key('_t_IntSeqSeq'): _M_MyUtil._t_IntSeqSeq = IcePy.defineSequence('::MyUtil::IntSeqSeq', (), _M_MyUtil._t_IntSeq) if not _M_MyUtil.__dict__.has_key('_t_IntArray'): _M_MyUtil._t_IntArray = IcePy.defineSequence('::MyUtil::IntArray', (), IcePy._t_int) if not _M_MyUtil.__dict__.has_key('_t_LongSeq'): _M_MyUtil._t_LongSeq = IcePy.defineSequence('::MyUtil::LongSeq', (), IcePy._t_long)
__name__ = 'omero.model' if not _M_omero.model.__dict__.has_key('ExperimentType'): _M_omero.model._t_ExperimentType = IcePy.declareClass('::omero::model::ExperimentType') _M_omero.model._t_ExperimentTypePrx = IcePy.declareProxy('::omero::model::ExperimentType') 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('_t_ExperimentMicrobeamManipulationSeq'): _M_omero.model._t_ExperimentMicrobeamManipulationSeq = IcePy.defineSequence('::omero::model::ExperimentMicrobeamManipulationSeq', (), _M_omero.model._t_MicrobeamManipulation) if not _M_omero.model.__dict__.has_key('Experiment'): _M_omero.model.Experiment = Ice.createTempClass() class Experiment(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _type=None, _microbeamManipulationSeq=None, _microbeamManipulationLoaded=False, _description=None): if __builtin__.type(self) == _M_omero.model.Experiment: raise RuntimeError('omero.model.Experiment is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version self._type = _type self._microbeamManipulationSeq = _microbeamManipulationSeq self._microbeamManipulationLoaded = _microbeamManipulationLoaded self._description = _description def ice_ids(self, current=None):
_M_omero.model._t_SessionPrx = IcePy.declareProxy('::omero::model::Session') if not _M_omero.model.__dict__.has_key('NodeAnnotationLink'): _M_omero.model._t_NodeAnnotationLink = IcePy.declareClass('::omero::model::NodeAnnotationLink') _M_omero.model._t_NodeAnnotationLinkPrx = IcePy.declareProxy('::omero::model::NodeAnnotationLink') 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('_t_NodeSessionsSeq'): _M_omero.model._t_NodeSessionsSeq = IcePy.defineSequence('::omero::model::NodeSessionsSeq', (), _M_omero.model._t_Session) if not _M_omero.model.__dict__.has_key('_t_NodeAnnotationLinksSeq'): _M_omero.model._t_NodeAnnotationLinksSeq = IcePy.defineSequence('::omero::model::NodeAnnotationLinksSeq', (), _M_omero.model._t_NodeAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_NodeLinkedAnnotationSeq'): _M_omero.model._t_NodeLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::NodeLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('Node'): _M_omero.model.Node = Ice.createTempClass() class Node(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _sessionsSeq=None, _sessionsLoaded=False, _uuid=None, _conn=None, _up=None, _down=None, _scale=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None): if __builtin__.type(self) == _M_omero.model.Node: raise RuntimeError('omero.model.Node is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version
_M_omero.model._t_DatasetPrx = IcePy.declareProxy('::omero::model::Dataset') if not _M_omero.model.__dict__.has_key('ProjectAnnotationLink'): _M_omero.model._t_ProjectAnnotationLink = IcePy.declareClass('::omero::model::ProjectAnnotationLink') _M_omero.model._t_ProjectAnnotationLinkPrx = IcePy.declareProxy('::omero::model::ProjectAnnotationLink') 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('_t_ProjectDatasetLinksSeq'): _M_omero.model._t_ProjectDatasetLinksSeq = IcePy.defineSequence('::omero::model::ProjectDatasetLinksSeq', (), _M_omero.model._t_ProjectDatasetLink) if not _M_omero.model.__dict__.has_key('_t_ProjectLinkedDatasetSeq'): _M_omero.model._t_ProjectLinkedDatasetSeq = IcePy.defineSequence('::omero::model::ProjectLinkedDatasetSeq', (), _M_omero.model._t_Dataset) if not _M_omero.model.__dict__.has_key('_t_ProjectAnnotationLinksSeq'): _M_omero.model._t_ProjectAnnotationLinksSeq = IcePy.defineSequence('::omero::model::ProjectAnnotationLinksSeq', (), _M_omero.model._t_ProjectAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_ProjectLinkedAnnotationSeq'): _M_omero.model._t_ProjectLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::ProjectLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('Project'): _M_omero.model.Project = Ice.createTempClass() class Project(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _datasetLinksSeq=None, _datasetLinksLoaded=False, _datasetLinksCountPerOwner=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _name=None, _description=None): if __builtin__.type(self) == _M_omero.model.Project:
# Ice version 3.4.2 # # <auto-generated> # # Generated from file `EndpointF.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('TCPEndpointInfo'): _M_Ice._t_TCPEndpointInfo = IcePy.declareClass('::Ice::TCPEndpointInfo') if not _M_Ice.__dict__.has_key('UDPEndpointInfo'): _M_Ice._t_UDPEndpointInfo = IcePy.declareClass('::Ice::UDPEndpointInfo') if not _M_Ice.__dict__.has_key('Endpoint'): _M_Ice._t_Endpoint = IcePy.declareClass('::Ice::Endpoint') if not _M_Ice.__dict__.has_key('_t_EndpointSeq'): _M_Ice._t_EndpointSeq = IcePy.defineSequence('::Ice::EndpointSeq', (), _M_Ice._t_Endpoint) # End of module Ice
__repr__ = __str__ _M_MPMS._t_MediaControlInfo = IcePy.defineStruct('::MPMS::MediaControlInfo', MediaControlInfo, ( ("id", IcePy._t_string), ("name", IcePy._t_string), ("url", IcePy._t_string), ("player", IcePy._t_string), ("width", IcePy._t_int), ("height", IcePy._t_int) )) _M_MPMS.MediaControlInfo = MediaControlInfo del MediaControlInfo if not _M_MPMS.__dict__.has_key('_t_MediaControlInfoList'): _M_MPMS._t_MediaControlInfoList = IcePy.defineSequence('::MPMS::MediaControlInfoList', _M_MPMS._t_MediaControlInfo) if not _M_MPMS.__dict__.has_key('IEToolbarControlInfo'): _M_MPMS.IEToolbarControlInfo = Ice.createTempClass() class IEToolbarControlInfo(object): def __init__(self, mciList=None): self.mciList = mciList def __hash__(self): _h = 0 if self.mciList: for _i0 in self.mciList: _h = 5 * _h + __builtin__.hash(_i0) return _h % 0x7fffffff def __eq__(self, other):
def __str__(self): return IcePy.stringify(self, _M_Notification._t_caseResult) __repr__ = __str__ _M_Notification._t_caseResult = IcePy.defineStruct( '::Notification::caseResult', caseResult, (), (('registrationTimeStamp', (), _M_Notification._t_timeStamp), ('expectedResolutionTime', (), IcePy._t_int), ('resultMessage', (), IcePy._t_string))) _M_Notification.caseResult = caseResult del caseResult if '_t_batchedResults' not in _M_Notification.__dict__: _M_Notification._t_batchedResults = IcePy.defineSequence( '::Notification::batchedResults', (), _M_Notification._t_caseResult) _M_Notification._t_Notifier = IcePy.defineValue('::Notification::Notifier', Ice.Value, -1, (), False, True, None, ()) if 'NotifierPrx' not in _M_Notification.__dict__: _M_Notification.NotifierPrx = Ice.createTempClass() class NotifierPrx(Ice.ObjectPrx): def singleNotify(self, result, context=None): return _M_Notification.Notifier._op_singleNotify.invoke( self, ((result, ), context)) def singleNotifyAsync(self, result, context=None): return _M_Notification.Notifier._op_singleNotify.invokeAsync(
# # Generated from file `SRTcontrol.ice' # # Warning: do not edit this file. # # </auto-generated> # import Ice, IcePy, __builtin__ # Start of module SRTControl _M_SRTControl = Ice.openModule('SRTControl') __name__ = 'SRTControl' if not _M_SRTControl.__dict__.has_key('_t_ports'): _M_SRTControl._t_ports = IcePy.defineSequence('::SRTControl::ports', (), IcePy._t_string) if not _M_SRTControl.__dict__.has_key('_t_spectrum'): _M_SRTControl._t_spectrum = IcePy.defineSequence('::SRTControl::spectrum', (), IcePy._t_float) if not _M_SRTControl.__dict__.has_key('AntennaStatus'): _M_SRTControl.AntennaStatus = Ice.createTempClass() class AntennaStatus(object): def __init__(self, az=0.0, el=0.0, aznow=0.0, elnow=0.0, axis=0, tostow=0, elatstow=0, azatstow=0, slew=0, serialport='', lastSRTCom='', lastSerialMsg=''): self.az = az self.el = el self.aznow = aznow self.elnow = elnow self.axis = axis self.tostow = tostow self.elatstow = elatstow
_M_omero.model._t_ChannelBindingPrx = IcePy.declareProxy('::omero::model::ChannelBinding') if 'QuantumDef' not in _M_omero.model.__dict__: _M_omero.model._t_QuantumDef = IcePy.declareClass('::omero::model::QuantumDef') _M_omero.model._t_QuantumDefPrx = IcePy.declareProxy('::omero::model::QuantumDef') if 'ProjectionDef' not in _M_omero.model.__dict__: _M_omero.model._t_ProjectionDef = IcePy.declareClass('::omero::model::ProjectionDef') _M_omero.model._t_ProjectionDefPrx = IcePy.declareProxy('::omero::model::ProjectionDef') 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 '_t_RenderingDefWaveRenderingSeq' not in _M_omero.model.__dict__: _M_omero.model._t_RenderingDefWaveRenderingSeq = IcePy.defineSequence('::omero::model::RenderingDefWaveRenderingSeq', (), _M_omero.model._t_ChannelBinding) if '_t_RenderingDefProjectionsSeq' not in _M_omero.model.__dict__: _M_omero.model._t_RenderingDefProjectionsSeq = IcePy.defineSequence('::omero::model::RenderingDefProjectionsSeq', (), _M_omero.model._t_ProjectionDef) if 'RenderingDef' not in _M_omero.model.__dict__: _M_omero.model.RenderingDef = Ice.createTempClass() class RenderingDef(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _pixels=None, _defaultZ=None, _defaultT=None, _model=None, _waveRenderingSeq=None, _waveRenderingLoaded=False, _name=None, _compression=None, _quantization=None, _projectionsSeq=None, _projectionsLoaded=False): if Ice.getType(self) == _M_omero.model.RenderingDef: raise RuntimeError('omero.model.RenderingDef is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version self._pixels = _pixels self._defaultZ = _defaultZ self._defaultT = _defaultT
_M_bfd.kafkaconsumerclient._t_RetInfoPrx = IcePy.defineProxy('::bfd::kafkaconsumerclient::RetInfo', RetInfoPrx) _M_bfd.kafkaconsumerclient._t_RetInfo = IcePy.defineClass('::bfd::kafkaconsumerclient::RetInfo', RetInfo, (), False, None, (), ( ('message', (), IcePy._t_string), ('ret', (), IcePy._t_int) )) RetInfo.ice_type = _M_bfd.kafkaconsumerclient._t_RetInfo _M_bfd.kafkaconsumerclient.RetInfo = RetInfo del RetInfo _M_bfd.kafkaconsumerclient.RetInfoPrx = RetInfoPrx del RetInfoPrx if not _M_bfd.kafkaconsumerclient.__dict__.has_key('_t_RetInfoSeq'): _M_bfd.kafkaconsumerclient._t_RetInfoSeq = IcePy.defineSequence('::bfd::kafkaconsumerclient::RetInfoSeq', (), _M_bfd.kafkaconsumerclient._t_RetInfo) if not _M_bfd.kafkaconsumerclient.__dict__.has_key('KafkaConsumerClientManager'): _M_bfd.kafkaconsumerclient.KafkaConsumerClientManager = Ice.createTempClass() class KafkaConsumerClientManager(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_bfd.kafkaconsumerclient.KafkaConsumerClientManager: raise RuntimeError('bfd.kafkaconsumerclient.KafkaConsumerClientManager is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::bfd::kafkaconsumerclient::KafkaConsumerClientManager') def ice_id(self, current=None): return '::bfd::kafkaconsumerclient::KafkaConsumerClientManager' def ice_staticId():
Action._ice_type = _M_guitarlib._t_Action Action._op_perform = IcePy.Operation('perform', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), None, ()) Action._op_getEventType = IcePy.Operation('getEventType', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, (), (), (), IcePy._t_string, ()) _M_guitarlib.Action = Action del Action _M_guitarlib.ActionPrx = ActionPrx del ActionPrx if not _M_guitarlib.__dict__.has_key('_t_PropertyMap'): _M_guitarlib._t_PropertyMap = IcePy.defineDictionary('::guitarlib::PropertyMap', (), IcePy._t_string, IcePy._t_string) if not _M_guitarlib.__dict__.has_key('_t_EventList'): _M_guitarlib._t_EventList = IcePy.defineSequence('::guitarlib::EventList', (), _M_guitarlib._t_ActionPrx) if not _M_guitarlib.__dict__.has_key('_t_WidgetList'): _M_guitarlib._t_WidgetList = IcePy.defineSequence('::guitarlib::WidgetList', (), _M_guitarlib._t_WidgetPrx) if not _M_guitarlib.__dict__.has_key('Widget'): _M_guitarlib.Widget = Ice.createTempClass() class Widget(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_guitarlib.Widget: raise RuntimeError('guitarlib.Widget is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::guitarlib::Widget') def ice_id(self, current=None):
_M_omero.model._t_EventPrx = IcePy.declareProxy('::omero::model::Event') if not _M_omero.model.__dict__.has_key('EventLog'): _M_omero.model._t_EventLog = IcePy.declareClass('::omero::model::EventLog') _M_omero.model._t_EventLogPrx = IcePy.declareProxy('::omero::model::EventLog') if not _M_omero.model.__dict__.has_key('Session'): _M_omero.model._t_Session = IcePy.declareClass('::omero::model::Session') _M_omero.model._t_SessionPrx = IcePy.declareProxy('::omero::model::Session') 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('_t_EventLogsSeq'): _M_omero.model._t_EventLogsSeq = IcePy.defineSequence('::omero::model::EventLogsSeq', (), _M_omero.model._t_EventLog) if not _M_omero.model.__dict__.has_key('Event'): _M_omero.model.Event = Ice.createTempClass() class Event(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _status=None, _time=None, _experimenter=None, _experimenterGroup=None, _type=None, _containingEvent=None, _logsSeq=None, _logsLoaded=False, _session=None): if __builtin__.type(self) == _M_omero.model.Event: raise RuntimeError('omero.model.Event is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._status = _status self._time = _time self._experimenter = _experimenter self._experimenterGroup = _experimenterGroup self._type = _type self._containingEvent = _containingEvent self._logsSeq = _logsSeq
def __str__(self): return IcePy.stringify(self, _M_mp3App._t_Song) __repr__ = __str__ _M_mp3App._t_Song = IcePy.defineStruct( '::mp3App::Song', Song, (), (('name', (), IcePy._t_string), ('artist', (), IcePy._t_string), ('genre', (), IcePy._t_string), ('length', (), IcePy._t_string), ('path', (), IcePy._t_string))) _M_mp3App.Song = Song del Song if '_t_playList' not in _M_mp3App.__dict__: _M_mp3App._t_playList = IcePy.defineSequence('::mp3App::playList', (), IcePy._t_string) _M_mp3App._t_Function = IcePy.defineValue('::mp3App::Function', Ice.Value, -1, (), False, True, None, ()) if 'FunctionPrx' not in _M_mp3App.__dict__: _M_mp3App.FunctionPrx = Ice.createTempClass() class FunctionPrx(Ice.ObjectPrx): def sendPlayList(self, seq, context=None): return _M_mp3App.Function._op_sendPlayList.invoke( self, ((seq, ), context)) def sendPlayListAsync(self, seq, context=None): return _M_mp3App.Function._op_sendPlayList.invokeAsync( self, ((seq, ), context))
# Included module Glacier2 _M_Glacier2 = Ice.openModule('Glacier2') # Start of module omero __name__ = 'omero' # Start of module omero.cmd _M_omero.cmd = Ice.openModule('omero.cmd') __name__ = 'omero.cmd' _M_omero.cmd.__doc__ = '''Simplified API that is intended for passing''' if not _M_omero.cmd.__dict__.has_key('_t_StringMap'): _M_omero.cmd._t_StringMap = IcePy.defineDictionary('::omero::cmd::StringMap', (), IcePy._t_string, IcePy._t_string) if not _M_omero.cmd.__dict__.has_key('_t_StringMapList'): _M_omero.cmd._t_StringMapList = IcePy.defineSequence('::omero::cmd::StringMapList', (), _M_omero.cmd._t_StringMap) if not _M_omero.cmd.__dict__.has_key('State'): _M_omero.cmd.State = Ice.createTempClass() class State(object): def __init__(self, val): assert(val >= 0 and val < 6) self.value = val def __str__(self): return self._names[self.value] __repr__ = __str__ def __hash__(self):
# Start of module games _M_games = Ice.openModule('games') __name__ = 'games' if not _M_games.__dict__.has_key('_t_HashValueSet'): _M_games._t_HashValueSet = IcePy.defineDictionary('::games::HashValueSet', (), IcePy._t_string, IcePy._t_string) if not _M_games.__dict__.has_key('_t_ReturnValueT'): _M_games._t_ReturnValueT = IcePy.defineDictionary('::games::ReturnValueT', (), IcePy._t_string, IcePy._t_string) if not _M_games.__dict__.has_key('_t_StreamDataT'): _M_games._t_StreamDataT = IcePy.defineSequence('::games::StreamDataT', (), IcePy._t_byte) if not _M_games.__dict__.has_key('_t_StringListT'): _M_games._t_StringListT = IcePy.defineSequence('::games::StringListT', (), IcePy._t_string) if not _M_games.__dict__.has_key('_t_HashValueListT'): _M_games._t_HashValueListT = IcePy.defineSequence( '::games::HashValueListT', (), _M_games._t_HashValueSet) if not _M_games.__dict__.has_key('_t_IntListT'): _M_games._t_IntListT = IcePy.defineSequence('::games::IntListT', (), IcePy._t_int) if not _M_games.__dict__.has_key('_t_StringListListT'): _M_games._t_StringListListT = IcePy.defineSequence(
_M_omero.model._t_PixelsPrx = IcePy.declareProxy('::omero::model::Pixels') if not _M_omero.model.__dict__.has_key('ChannelAnnotationLink'): _M_omero.model._t_ChannelAnnotationLink = IcePy.declareClass('::omero::model::ChannelAnnotationLink') _M_omero.model._t_ChannelAnnotationLinkPrx = IcePy.declareProxy('::omero::model::ChannelAnnotationLink') 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('_t_ChannelAnnotationLinksSeq'): _M_omero.model._t_ChannelAnnotationLinksSeq = IcePy.defineSequence('::omero::model::ChannelAnnotationLinksSeq', (), _M_omero.model._t_ChannelAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_ChannelLinkedAnnotationSeq'): _M_omero.model._t_ChannelLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::ChannelLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('Channel'): _M_omero.model.Channel = Ice.createTempClass() class Channel(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _statsInfo=None, _red=None, _green=None, _blue=None, _alpha=None, _logicalChannel=None, _pixels=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None): if __builtin__.type(self) == _M_omero.model.Channel: raise RuntimeError('omero.model.Channel is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version self._statsInfo = _statsInfo self._red = _red self._green = _green
return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_jderobot._t_RGBSegment) __repr__ = __str__ _M_jderobot._t_RGBSegment = IcePy.defineStruct( '::jderobot::RGBSegment', RGBSegment, (), (('seg', (), _M_jderobot._t_Segment), ('c', (), _M_jderobot._t_Color))) _M_jderobot.RGBSegment = RGBSegment del RGBSegment if '_t_Segments' not in _M_jderobot.__dict__: _M_jderobot._t_Segments = IcePy.defineSequence('::jderobot::Segments', (), _M_jderobot._t_RGBSegment) if '_t_Points' not in _M_jderobot.__dict__: _M_jderobot._t_Points = IcePy.defineSequence('::jderobot::Points', (), _M_jderobot._t_RGBPoint) if '_t_File' not in _M_jderobot.__dict__: _M_jderobot._t_File = IcePy.defineSequence('::jderobot::File', (), IcePy._t_byte) if 'bufferSegments' not in _M_jderobot.__dict__: _M_jderobot.bufferSegments = Ice.createTempClass() class bufferSegments(object): def __init__(self, buffer=None, refresh=False): self.buffer = buffer
import IcePatch2_FileInfo_ice # Included module Ice _M_Ice = Ice.openModule('Ice') # Included module IcePatch2 _M_IcePatch2 = Ice.openModule('IcePatch2') # Start of module IcePatch2 __name__ = 'IcePatch2' _M_IcePatch2.__doc__ = '''IcePatch can be used to update file hiearchies in a simple and efficient manner. Checksums ensure file integrity, and data is compressed before download.''' if not _M_IcePatch2.__dict__.has_key('_t_ByteSeqSeq'): _M_IcePatch2._t_ByteSeqSeq = IcePy.defineSequence('::IcePatch2::ByteSeqSeq', (), _M_Ice._t_ByteSeq) if not _M_IcePatch2.__dict__.has_key('PartitionOutOfRangeException'): _M_IcePatch2.PartitionOutOfRangeException = Ice.createTempClass() class PartitionOutOfRangeException(Ice.UserException): '''The partition argument for FileServer#getFileInfoSeq was not in the range 0-255.''' def __init__(self): pass def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _ice_name = 'IcePatch2::PartitionOutOfRangeException'
_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'): _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('_t_WellSampleAnnotationLinksSeq'): _M_omero.model._t_WellSampleAnnotationLinksSeq = IcePy.defineSequence('::omero::model::WellSampleAnnotationLinksSeq', (), _M_omero.model._t_WellSampleAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_WellSampleLinkedAnnotationSeq'): _M_omero.model._t_WellSampleLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::WellSampleLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('WellSample'): _M_omero.model.WellSample = Ice.createTempClass() class WellSample(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _posX=None, _posY=None, _timepoint=None, _plateAcquisition=None, _well=None, _image=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None): if __builtin__.type(self) == _M_omero.model.WellSample: raise RuntimeError('omero.model.WellSample is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version self._posX = _posX self._posY = _posY self._timepoint = _timepoint
_M_omero.model._t_OriginalFilePrx = IcePy.declareProxy('::omero::model::OriginalFile') if not _M_omero.model.__dict__.has_key('RoiAnnotationLink'): _M_omero.model._t_RoiAnnotationLink = IcePy.declareClass('::omero::model::RoiAnnotationLink') _M_omero.model._t_RoiAnnotationLinkPrx = IcePy.declareProxy('::omero::model::RoiAnnotationLink') 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('_t_RoiShapesSeq'): _M_omero.model._t_RoiShapesSeq = IcePy.defineSequence('::omero::model::RoiShapesSeq', (), _M_omero.model._t_Shape) if not _M_omero.model.__dict__.has_key('_t_RoiAnnotationLinksSeq'): _M_omero.model._t_RoiAnnotationLinksSeq = IcePy.defineSequence('::omero::model::RoiAnnotationLinksSeq', (), _M_omero.model._t_RoiAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_RoiLinkedAnnotationSeq'): _M_omero.model._t_RoiLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::RoiLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('Roi'): _M_omero.model.Roi = Ice.createTempClass() class Roi(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _shapesSeq=None, _shapesLoaded=False, _image=None, _source=None, _namespaces=None, _keywords=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _description=None): if __builtin__.type(self) == _M_omero.model.Roi: raise RuntimeError('omero.model.Roi is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version
6: DataType.Int8, 7: DataType.Int16, 8: DataType.Int32, 9: DataType.Int64, 10: DataType.Float, 11: DataType.Double } _M_device_repo_ice._t_DataType = IcePy.defineEnum( '::device_repo_ice::DataType', DataType, (), DataType._enumerators) _M_device_repo_ice.DataType = DataType del DataType if '_t_bytes' not in _M_device_repo_ice.__dict__: _M_device_repo_ice._t_bytes = IcePy.defineSequence( '::device_repo_ice::bytes', (), IcePy._t_byte) if '_t_ints' not in _M_device_repo_ice.__dict__: _M_device_repo_ice._t_ints = IcePy.defineSequence( '::device_repo_ice::ints', (), IcePy._t_int) if '_t_doubles' not in _M_device_repo_ice.__dict__: _M_device_repo_ice._t_doubles = IcePy.defineSequence( '::device_repo_ice::doubles', (), IcePy._t_double) if '_t_strings' not in _M_device_repo_ice.__dict__: _M_device_repo_ice._t_strings = IcePy.defineSequence( '::device_repo_ice::strings', (), IcePy._t_string) if 'DataSet' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DataSet = Ice.createTempClass()
# # Generated from file `IceSRTClient.ice' # # Warning: do not edit this file. # # </auto-generated> # import Ice, IcePy # Start of module SRTClient _M_SRTClient = Ice.openModule('SRTClient') __name__ = 'SRTClient' if '_t_spectrum' not in _M_SRTClient.__dict__: _M_SRTClient._t_spectrum = IcePy.defineSequence('::SRTClient::spectrum', (), IcePy._t_float) if 'stamp' not in _M_SRTClient.__dict__: _M_SRTClient.stamp = Ice.createTempClass() class stamp(object): def __init__(self, name='', timdate='', aznow=0.0, elnow=0.0, temperature=0.0, freq0=0.0, av=0, avc=0, nfreq=0, freqsep=0.0): self.name = name self.timdate = timdate self.aznow = aznow self.elnow = elnow self.temperature = temperature self.freq0 = freq0 self.av = av self.avc = avc self.nfreq = nfreq self.freqsep = freqsep
def __str__(self): return IcePy.stringify(self, _M_IceMX._t_MetricsFailures) __repr__ = __str__ _M_IceMX._t_MetricsFailures = IcePy.defineStruct( '::IceMX::MetricsFailures', MetricsFailures, (), (('id', (), IcePy._t_string), ('failures', (), _M_IceMX._t_StringIntDict))) _M_IceMX.MetricsFailures = MetricsFailures del MetricsFailures if '_t_MetricsFailuresSeq' not in _M_IceMX.__dict__: _M_IceMX._t_MetricsFailuresSeq = IcePy.defineSequence( '::IceMX::MetricsFailuresSeq', (), _M_IceMX._t_MetricsFailures) if '_t_MetricsMap' not in _M_IceMX.__dict__: _M_IceMX._t_MetricsMap = IcePy.defineSequence('::IceMX::MetricsMap', (), _M_IceMX._t_Metrics) if '_t_MetricsView' not in _M_IceMX.__dict__: _M_IceMX._t_MetricsView = IcePy.defineDictionary('::IceMX::MetricsView', (), IcePy._t_string, _M_IceMX._t_MetricsMap) if 'UnknownMetricsView' not in _M_IceMX.__dict__: _M_IceMX.UnknownMetricsView = Ice.createTempClass() class UnknownMetricsView(Ice.UserException): '''Raised if a metrics view cannot be found.'''
def __str__(self): return IcePy.stringify(self, _M_MPMS._t_MediaControlInfo) __repr__ = __str__ _M_MPMS._t_MediaControlInfo = IcePy.defineStruct('::MPMS::MediaControlInfo', MediaControlInfo, ( ("url", IcePy._t_string), ("player", IcePy._t_string), ("width", IcePy._t_int), ("height", IcePy._t_int) )) _M_MPMS.MediaControlInfo = MediaControlInfo del MediaControlInfo _M_MPMS._t_MediaControlInfoList = IcePy.defineSequence('::MPMS::MediaControlInfoList', _M_MPMS._t_MediaControlInfo) _M_MPMS.PlayPolicy = Ice.createTempClass() class PlayPolicy(object): def __init__(self, fpcs=_M_MPMS.fpcSetting(), qq=_M_MPMS.MediaControlInfo(), msn=_M_MPMS.MediaControlInfo()): self.fpcs = fpcs self.qq = qq self.msn = msn def __hash__(self): _h = 0 _h = 5 * _h + __builtin__.hash(self.fpcs) _h = 5 * _h + __builtin__.hash(self.qq) _h = 5 * _h + __builtin__.hash(self.msn) return _h % 0x7fffffff
def __str__(self): return IcePy.stringify(self, _M_svc._t_CopyRight) __repr__ = __str__ _M_svc._t_CopyRight = IcePy.defineStruct( '::svc::CopyRight', CopyRight, (), (('approvalDate', (), IcePy._t_string), ('name', (), IcePy._t_string), ('cn', (), IcePy._t_string), ('registeredNo', (), IcePy._t_string), ('category', (), IcePy._t_string), ('version', (), IcePy._t_string))) _M_svc.CopyRight = CopyRight del CopyRight if '_t_RelatedPersonSeq' not in _M_svc.__dict__: _M_svc._t_RelatedPersonSeq = IcePy.defineSequence( '::svc::RelatedPersonSeq', (), _M_svc._t_RelatedPerson) if '_t_PartnerSeq' not in _M_svc.__dict__: _M_svc._t_PartnerSeq = IcePy.defineSequence('::svc::PartnerSeq', (), _M_svc._t_Partner) if '_t_BrandSeq' not in _M_svc.__dict__: _M_svc._t_BrandSeq = IcePy.defineSequence('::svc::BrandSeq', (), _M_svc._t_Brand) if '_t_CopyRightSeq' not in _M_svc.__dict__: _M_svc._t_CopyRightSeq = IcePy.defineSequence('::svc::CopyRightSeq', (), _M_svc._t_CopyRight) if '_t_stringReq' not in _M_svc.__dict__: _M_svc._t_stringReq = IcePy.defineSequence('::svc::stringReq', (),
_M_omero.metadatastore._t_IObjectContainer = IcePy.defineClass('::omero::metadatastore::IObjectContainer', IObjectContainer, (), False, None, (), ( ('LSID', (), IcePy._t_string), ('indexes', (), _M_omero.api._t_StringIntMap), ('sourceObject', (), _M_omero.model._t_IObject) )) IObjectContainer._ice_type = _M_omero.metadatastore._t_IObjectContainer _M_omero.metadatastore.IObjectContainer = IObjectContainer del IObjectContainer _M_omero.metadatastore.IObjectContainerPrx = IObjectContainerPrx del IObjectContainerPrx if not _M_omero.metadatastore.__dict__.has_key('_t_IObjectContainerArray'): _M_omero.metadatastore._t_IObjectContainerArray = IcePy.defineSequence('::omero::metadatastore::IObjectContainerArray', (), _M_omero.metadatastore._t_IObjectContainer) # End of module omero.metadatastore __name__ = 'omero' # Start of module omero.api __name__ = 'omero.api' if not _M_omero.api.__dict__.has_key('MetadataStore'): _M_omero.api.MetadataStore = Ice.createTempClass() class MetadataStore(_M_omero.api.StatefulServiceInterface): '''Server-side interface for import.''' def __init__(self): if __builtin__.type(self) == _M_omero.api.MetadataStore: raise RuntimeError('omero.api.MetadataStore is an abstract class')
_M_xce.serverstate._t_ServerStateInfoMutilPrx = IcePy.defineProxy('::xce::serverstate::ServerStateInfoMutil', ServerStateInfoMutilPrx) _M_xce.serverstate._t_ServerStateInfoMutil = IcePy.defineClass('::xce::serverstate::ServerStateInfoMutil', ServerStateInfoMutil, (), False, _M_xce.serverstate._t_ServerStateInfo, (), ( ('prxMap', (), _M_xce.serverstate._t_ServerPrxMap), ('statusMap', (), _M_xce.serverstate._t_ServerPrxStatusMap) )) ServerStateInfoMutil.ice_type = _M_xce.serverstate._t_ServerStateInfoMutil _M_xce.serverstate.ServerStateInfoMutil = ServerStateInfoMutil del ServerStateInfoMutil _M_xce.serverstate.ServerStateInfoMutilPrx = ServerStateInfoMutilPrx del ServerStateInfoMutilPrx if not _M_xce.serverstate.__dict__.has_key('_t_ServerStateSeq'): _M_xce.serverstate._t_ServerStateSeq = IcePy.defineSequence('::xce::serverstate::ServerStateSeq', (), _M_xce.serverstate._t_ServerStateInfo) # End of module xce.serverstate __name__ = 'xce' # Start of module xce.clusterstate _M_xce.clusterstate = Ice.openModule('xce.clusterstate') __name__ = 'xce.clusterstate' if not _M_xce.clusterstate.__dict__.has_key('_t_ServerStateMap'): _M_xce.clusterstate._t_ServerStateMap = IcePy.defineDictionary('::xce::clusterstate::ServerStateMap', (), IcePy._t_int, _M_xce.serverstate._t_ServerStateSeq) if not _M_xce.clusterstate.__dict__.has_key('ClusterStateInfo'): _M_xce.clusterstate.ClusterStateInfo = Ice.createTempClass() class ClusterStateInfo(_M_MyUtil.SbjState):
# ********************************************************************** # Ice version 3.3.1 # Generated from file `Common.ice' import Ice, IcePy, __builtin__ if not Ice.__dict__.has_key("_struct_marker"): Ice._struct_marker = object() # Start of module echoes _M_echoes = Ice.openModule('echoes') __name__ = 'echoes' if not _M_echoes.__dict__.has_key('_t_StringSeq'): _M_echoes._t_StringSeq = IcePy.defineSequence('::echoes::StringSeq', (), IcePy._t_string) if not _M_echoes.__dict__.has_key('ScreenLocation'): _M_echoes.ScreenLocation = Ice.createTempClass() class ScreenLocation(object): def __init__(self, x=0, y=0): self.x = x self.y = y def __hash__(self): _h = 0 _h = 5 * _h + __builtin__.hash(self.x) _h = 5 * _h + __builtin__.hash(self.y) return _h % 0x7fffffff def __cmp__(self, other):
return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_Ice.Identity): return self.name >= other.name or self.category >= other.category elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Ice._t_Identity) __repr__ = __str__ _M_Ice._t_Identity = IcePy.defineStruct('::Ice::Identity', Identity, (), ( ('name', (), IcePy._t_string), ('category', (), IcePy._t_string) )) _M_Ice.Identity = Identity del Identity if not _M_Ice.__dict__.has_key('_t_ObjectDict'): _M_Ice._t_ObjectDict = IcePy.defineDictionary('::Ice::ObjectDict', (), _M_Ice._t_Identity, IcePy._t_Object) if not _M_Ice.__dict__.has_key('_t_IdentitySeq'): _M_Ice._t_IdentitySeq = IcePy.defineSequence('::Ice::IdentitySeq', (), _M_Ice._t_Identity) # End of module Ice
# Generated from file `Slice.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module M _M_M = Ice.openModule('M') __name__ = 'M' if '_t_Numbers' not in _M_M.__dict__: _M_M._t_Numbers = IcePy.defineSequence('::M::Numbers', ('python:list',), IcePy._t_int) if '_t_ByteList' not in _M_M.__dict__: _M_M._t_ByteList = IcePy.defineSequence('::M::ByteList', ('python:list',), _M_M._t_Numbers) if '_t_Img' not in _M_M.__dict__: _M_M._t_Img = IcePy.defineSequence('::M::Img', ('python:list',), _M_M._t_ByteList) _M_M._t_I = IcePy.defineValue('::M::I', Ice.Value, -1, (), False, True, None, ()) if 'IPrx' not in _M_M.__dict__: _M_M.IPrx = Ice.createTempClass() class IPrx(Ice.ObjectPrx): def prints(self, a, context=None): return _M_M.I._op_prints.invoke(self, ((a, ), context))
# Generated from file `RadarUtil.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module xidianRadar _M_xidianRadar = Ice.openModule('xidianRadar') __name__ = 'xidianRadar' if '_t_IntList' not in _M_xidianRadar.__dict__: _M_xidianRadar._t_IntList = IcePy.defineSequence('::xidianRadar::IntList', (), IcePy._t_int) if '_t_IntIntList' not in _M_xidianRadar.__dict__: _M_xidianRadar._t_IntIntList = IcePy.defineSequence('::xidianRadar::IntIntList', (), _M_xidianRadar._t_IntList) _M_xidianRadar._t_RadarUtil = IcePy.defineValue('::xidianRadar::RadarUtil', Ice.Value, -1, (), False, True, None, ()) if 'RadarUtilPrx' not in _M_xidianRadar.__dict__: _M_xidianRadar.RadarUtilPrx = Ice.createTempClass() class RadarUtilPrx(Ice.ObjectPrx): def recognitionRadar(self, r, context=None): return _M_xidianRadar.RadarUtil._op_recognitionRadar.invoke(self, ((r, ), context)) def recognitionRadarAsync(self, r, context=None): return _M_xidianRadar.RadarUtil._op_recognitionRadar.invokeAsync(self, ((r, ), context))
('z', (), IcePy._t_float, False, 0), ('h', (), IcePy._t_float, False, 0), ('q0', (), IcePy._t_float, False, 0), ('q1', (), IcePy._t_float, False, 0), ('q2', (), IcePy._t_float, False, 0), ('q3', (), IcePy._t_float, False, 0))) Pose3DData._ice_type = _M_jderobot._t_Pose3DData _M_jderobot.Pose3DData = Pose3DData del Pose3DData _M_jderobot.Pose3DDataPrx = Pose3DDataPrx del Pose3DDataPrx if '_t_PoseSequence' not in _M_jderobot.__dict__: _M_jderobot._t_PoseSequence = IcePy.defineSequence( '::jderobot::PoseSequence', (), _M_jderobot._t_Pose3DData) if 'MissionData' not in _M_jderobot.__dict__: _M_jderobot.MissionData = Ice.createTempClass() class MissionData(Ice.Object): """ Mission data information """ def __init__(self, mission=None): self.mission = mission def ice_ids(self, current=None): return ('::Ice::Object', '::jderobot::MissionData') def ice_id(self, current=None):
# # Generated from file `BuiltinSequences.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("_t_BoolSeq"): _M_Ice._t_BoolSeq = IcePy.defineSequence("::Ice::BoolSeq", (), IcePy._t_bool) if not _M_Ice.__dict__.has_key("_t_ByteSeq"): _M_Ice._t_ByteSeq = IcePy.defineSequence("::Ice::ByteSeq", (), IcePy._t_byte) if not _M_Ice.__dict__.has_key("_t_ShortSeq"): _M_Ice._t_ShortSeq = IcePy.defineSequence("::Ice::ShortSeq", (), IcePy._t_short) if not _M_Ice.__dict__.has_key("_t_IntSeq"): _M_Ice._t_IntSeq = IcePy.defineSequence("::Ice::IntSeq", (), IcePy._t_int) if not _M_Ice.__dict__.has_key("_t_LongSeq"): _M_Ice._t_LongSeq = IcePy.defineSequence("::Ice::LongSeq", (), IcePy._t_long) if not _M_Ice.__dict__.has_key("_t_FloatSeq"): _M_Ice._t_FloatSeq = IcePy.defineSequence("::Ice::FloatSeq", (), IcePy._t_float)
return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Ice._t_Identity) __repr__ = __str__ _M_Ice._t_Identity = IcePy.defineStruct('::Ice::Identity', Identity, (), (('name', (), IcePy._t_string), ('category', (), IcePy._t_string))) _M_Ice.Identity = Identity del Identity if '_t_ObjectDict' not in _M_Ice.__dict__: _M_Ice._t_ObjectDict = IcePy.defineDictionary('::Ice::ObjectDict', (), _M_Ice._t_Identity, IcePy._t_Value) if '_t_IdentitySeq' not in _M_Ice.__dict__: _M_Ice._t_IdentitySeq = IcePy.defineSequence('::Ice::IdentitySeq', (), _M_Ice._t_Identity) # End of module Ice Ice.sliceChecksums["::Ice::Identity"] = "a0c37867a69924a9fcc4bdf078f06da" Ice.sliceChecksums["::Ice::IdentitySeq"] = "90afa299fd9e7d7a17268cc22b5ca42"
def __str__(self): return IcePy.stringify(self, _M_server._t_Musique) __repr__ = __str__ _M_server._t_Musique = IcePy.defineStruct('::server::Musique', Musique, (), (('id', (), IcePy._t_int), ('name', (), IcePy._t_string), ('artist', (), IcePy._t_string))) _M_server.Musique = Musique del Musique if '_t_bdd' not in _M_server.__dict__: _M_server._t_bdd = IcePy.defineSequence('::server::bdd', (), _M_server._t_Musique) _M_server._t_ServeurIce = IcePy.defineValue('::server::ServeurIce', Ice.Value, -1, (), False, True, None, ()) if 'ServeurIcePrx' not in _M_server.__dict__: _M_server.ServeurIcePrx = Ice.createTempClass() class ServeurIcePrx(Ice.ObjectPrx): def ajouterMusique(self, name, context=None): return _M_server.ServeurIce._op_ajouterMusique.invoke( self, ((name, ), context)) def ajouterMusiqueAsync(self, name, context=None): return _M_server.ServeurIce._op_ajouterMusique.invokeAsync( self, ((name, ), context))
__repr__ = __str__ _M_StreamingServer._t_Track = IcePy.defineValue( '::StreamingServer::Track', Track, -1, (), False, False, None, (('title', (), IcePy._t_string, False, 0), ('album', (), IcePy._t_string, False, 0), ('artist', (), IcePy._t_string, False, 0), ('path', (), IcePy._t_string, False, 0))) Track._ice_type = _M_StreamingServer._t_Track _M_StreamingServer.Track = Track del Track if '_t_trackSequence' not in _M_StreamingServer.__dict__: _M_StreamingServer._t_trackSequence = IcePy.defineSequence( '::StreamingServer::trackSequence', (), _M_StreamingServer._t_Track) if 'Status' not in _M_StreamingServer.__dict__: _M_StreamingServer.Status = Ice.createTempClass() class Status(Ice.Value): def __init__(self, code=0, message=''): self.code = code self.message = message def ice_id(self): return '::StreamingServer::Status' @staticmethod def ice_staticId(): return '::StreamingServer::Status'
_M_FS._t_ExamplePrx = IcePy.defineProxy('::FS::Example', ExamplePrx) _M_FS._t_Example = IcePy.defineClass('::FS::Example', Example, (), False, None, (), (('apilevel', (), IcePy._t_short),)) Example._ice_type = _M_FS._t_Example _M_FS.Example = Example del Example _M_FS.ExamplePrx = ExamplePrx del ExamplePrx _M_FS._lambda = 0 if not _M_FS.__dict__.has_key('_t_StringSeq'): _M_FS._t_StringSeq = IcePy.defineSequence('::FS::StringSeq', (), IcePy._t_string) if not _M_FS.__dict__.has_key('_t_StringDict'): _M_FS._t_StringDict = IcePy.defineDictionary('::FS::StringDict', (), IcePy._t_string, IcePy._t_string) if not _M_FS.__dict__.has_key('mystruct'): _M_FS.mystruct = Ice.createTempClass() class mystruct(object): def __init__(self, mytype=0, bo=False, by=0, sh=0, i=0, l=0, f=0.0, d=0.0, str='', ss=None, sd=None, s=None, prx=None): self.mytype = mytype self.bo = bo self.by = by self.sh = sh self.i = i self.l = l self.f = f
def __str__(self): return IcePy.stringify(self, _M_IceStorm._t_LinkInfo) __repr__ = __str__ _M_IceStorm._t_LinkInfo = IcePy.defineStruct('::IceStorm::LinkInfo', LinkInfo, (), ( ('theTopic', (), _M_IceStorm._t_TopicPrx), ('name', (), IcePy._t_string), ('cost', (), IcePy._t_int) )) _M_IceStorm.LinkInfo = LinkInfo del LinkInfo if not _M_IceStorm.__dict__.has_key('_t_LinkInfoSeq'): _M_IceStorm._t_LinkInfoSeq = IcePy.defineSequence('::IceStorm::LinkInfoSeq', (), _M_IceStorm._t_LinkInfo) if not _M_IceStorm.__dict__.has_key('_t_QoS'): _M_IceStorm._t_QoS = IcePy.defineDictionary('::IceStorm::QoS', (), IcePy._t_string, IcePy._t_string) if not _M_IceStorm.__dict__.has_key('LinkExists'): _M_IceStorm.LinkExists = Ice.createTempClass() class LinkExists(Ice.UserException): '''This exception indicates that an attempt was made to create a link that already exists.''' def __init__(self, name=''): self.name = name def __str__(self): return IcePy.stringifyException(self)
_M_omero.model._t_WellSamplePrx = IcePy.declareProxy('::omero::model::WellSample') if 'PlateAcquisitionAnnotationLink' not in _M_omero.model.__dict__: _M_omero.model._t_PlateAcquisitionAnnotationLink = IcePy.declareClass('::omero::model::PlateAcquisitionAnnotationLink') _M_omero.model._t_PlateAcquisitionAnnotationLinkPrx = IcePy.declareProxy('::omero::model::PlateAcquisitionAnnotationLink') if 'Annotation' not in _M_omero.model.__dict__: _M_omero.model._t_Annotation = IcePy.declareClass('::omero::model::Annotation') _M_omero.model._t_AnnotationPrx = IcePy.declareProxy('::omero::model::Annotation') 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 '_t_PlateAcquisitionWellSampleSeq' not in _M_omero.model.__dict__: _M_omero.model._t_PlateAcquisitionWellSampleSeq = IcePy.defineSequence('::omero::model::PlateAcquisitionWellSampleSeq', (), _M_omero.model._t_WellSample) if '_t_PlateAcquisitionAnnotationLinksSeq' not in _M_omero.model.__dict__: _M_omero.model._t_PlateAcquisitionAnnotationLinksSeq = IcePy.defineSequence('::omero::model::PlateAcquisitionAnnotationLinksSeq', (), _M_omero.model._t_PlateAcquisitionAnnotationLink) if '_t_PlateAcquisitionLinkedAnnotationSeq' not in _M_omero.model.__dict__: _M_omero.model._t_PlateAcquisitionLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::PlateAcquisitionLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if 'PlateAcquisition' not in _M_omero.model.__dict__: _M_omero.model.PlateAcquisition = Ice.createTempClass() class PlateAcquisition(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _name=None, _startTime=None, _endTime=None, _maximumFieldCount=None, _plate=None, _wellSampleSeq=None, _wellSampleLoaded=False, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _description=None): if Ice.getType(self) == _M_omero.model.PlateAcquisition: raise RuntimeError('omero.model.PlateAcquisition is an abstract class') _M_omero.model.IObject.__init__(self, _id, _details, _loaded) self._version = _version
def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _ice_name = 'Utils::OperationNotExistError' _M_Utils._t_OperationNotExistError = IcePy.defineException('::Utils::OperationNotExistError', OperationNotExistError, (), False, _M_Utils._t_ErrorBase, ()) OperationNotExistError._ice_type = _M_Utils._t_OperationNotExistError _M_Utils.OperationNotExistError = OperationNotExistError del OperationNotExistError if '_t_BinaryStream' not in _M_Utils.__dict__: _M_Utils._t_BinaryStream = IcePy.defineSequence('::Utils::BinaryStream', (), IcePy._t_byte) if 'Callable' not in _M_Utils.__dict__: _M_Utils.Callable = Ice.createTempClass() class Callable(Ice.Object): def __init__(self): if Ice.getType(self) == _M_Utils.Callable: raise RuntimeError('Utils.Callable is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::Utils::Callable') def ice_id(self, current=None): return '::Utils::Callable' def ice_staticId():
# # 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_jderobot._t_RGBSegment) __repr__ = __str__ _M_jderobot._t_RGBSegment = IcePy.defineStruct('::jderobot::RGBSegment', RGBSegment, (), ( ('seg', (), _M_jderobot._t_Segment), ('c', (), _M_jderobot._t_Color) )) _M_jderobot.RGBSegment = RGBSegment del RGBSegment if '_t_Segments' not in _M_jderobot.__dict__: _M_jderobot._t_Segments = IcePy.defineSequence('::jderobot::Segments', (), _M_jderobot._t_RGBSegment) if '_t_Points' not in _M_jderobot.__dict__: _M_jderobot._t_Points = IcePy.defineSequence('::jderobot::Points', (), _M_jderobot._t_RGBPoint) if 'bufferSegments' not in _M_jderobot.__dict__: _M_jderobot.bufferSegments = Ice.createTempClass() class bufferSegments(object): def __init__(self, buffer=None, refresh=False): self.buffer = buffer self.refresh = refresh def __eq__(self, other): if other is None: return False elif not isinstance(other, _M_jderobot.bufferSegments):
# # Generated from file `IceSRTClient.ice' # # Warning: do not edit this file. # # </auto-generated> # import Ice, IcePy # Start of module SRTClient _M_SRTClient = Ice.openModule('SRTClient') __name__ = 'SRTClient' if '_t_spectrum' not in _M_SRTClient.__dict__: _M_SRTClient._t_spectrum = IcePy.defineSequence('::SRTClient::spectrum', (), IcePy._t_float) if 'stamp' not in _M_SRTClient.__dict__: _M_SRTClient.stamp = Ice.createTempClass() class stamp(object): def __init__(self, name='', timdate='', aznow=0.0, elnow=0.0, temperature=0.0, freq0=0.0, av=0, avc=0, nfreq=0,
1: CoffeeType.AMERICANO, 2: CoffeeType.FLATWHITE, 3: CoffeeType.CAPPUCCINO, 4: CoffeeType.LATTE } _M_SmartHouse._t_CoffeeType = IcePy.defineEnum('::SmartHouse::CoffeeType', CoffeeType, (), CoffeeType._enumerators) _M_SmartHouse.CoffeeType = CoffeeType del CoffeeType if '_t_CurrentlyAvailableCoffeeTypes' not in _M_SmartHouse.__dict__: _M_SmartHouse._t_CurrentlyAvailableCoffeeTypes = IcePy.defineSequence( '::SmartHouse::CurrentlyAvailableCoffeeTypes', (), _M_SmartHouse._t_CoffeeType) if 'Time' not in _M_SmartHouse.__dict__: _M_SmartHouse.Time = Ice.createTempClass() class Time(object): def __init__(self, hour=0, minute=0, second=0): self.hour = hour self.minute = minute self.second = second def __hash__(self): _h = 0 _h = 5 * _h + Ice.getHash(self.hour) _h = 5 * _h + Ice.getHash(self.minute)
return IcePy.stringify(self, _M_Meteorologia._t_MedicionHora) __repr__ = __str__ _M_Meteorologia._t_MedicionHora = IcePy.defineStruct( '::Meteorologia::MedicionHora', MedicionHora, (), (('dia', (), IcePy._t_string), ('hora', (), IcePy._t_string), ('temp', (), IcePy._t_string), ('text', (), IcePy._t_string), ('humedad', (), IcePy._t_string), ('viento', (), IcePy._t_string), ('vientoDireccion', (), IcePy._t_string))) _M_Meteorologia.MedicionHora = MedicionHora del MedicionHora if '_t_Mediciones' not in _M_Meteorologia.__dict__: _M_Meteorologia._t_Mediciones = IcePy.defineSequence( '::Meteorologia::Mediciones', (), _M_Meteorologia._t_MedicionDia) if '_t_MedicionesHora' not in _M_Meteorologia.__dict__: _M_Meteorologia._t_MedicionesHora = IcePy.defineSequence( '::Meteorologia::MedicionesHora', (), _M_Meteorologia._t_MedicionHora) _M_Meteorologia._t_Conexion = IcePy.defineValue('::Meteorologia::Conexion', Ice.Value, -1, (), False, True, None, ()) if 'ConexionPrx' not in _M_Meteorologia.__dict__: _M_Meteorologia.ConexionPrx = Ice.createTempClass() class ConexionPrx(Ice.ObjectPrx): def reporteSemanal(self, ciudad, context=None): return _M_Meteorologia.Conexion._op_reporteSemanal.invoke(
# Generated from file `Tester.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module Tester _M_Tester = Ice.openModule('Tester') __name__ = 'Tester' if '_t_SeqInt' not in _M_Tester.__dict__: _M_Tester._t_SeqInt = IcePy.defineSequence('::Tester::SeqInt', (), IcePy._t_long) if '_t_SeqString' not in _M_Tester.__dict__: _M_Tester._t_SeqString = IcePy.defineSequence('::Tester::SeqString', (), IcePy._t_string) if '_t_SeqDouble' not in _M_Tester.__dict__: _M_Tester._t_SeqDouble = IcePy.defineSequence('::Tester::SeqDouble', (), IcePy._t_double) if 'SmallData' not in _M_Tester.__dict__: _M_Tester.SmallData = Ice.createTempClass() class SmallData(object): def __init__(self, n1=0, n2=0, s1='', b1=False, iSeq1=None): self.n1 = n1
Color._enumerators = { 0: Color.RED, 1: Color.BLUE, 2: Color.GREEN, 3: Color.YELLOW, 4: Color.WHITE } _M_SmartHouse._t_Color = IcePy.defineEnum('::SmartHouse::Color', Color, (), Color._enumerators) _M_SmartHouse.Color = Color del Color if '_t_AvailableTeaTypes' not in _M_SmartHouse.__dict__: _M_SmartHouse._t_AvailableTeaTypes = IcePy.defineSequence( '::SmartHouse::AvailableTeaTypes', (), _M_SmartHouse._t_TeaType) if '_t_AvailableCoffeeTypes' not in _M_SmartHouse.__dict__: _M_SmartHouse._t_AvailableCoffeeTypes = IcePy.defineSequence( '::SmartHouse::AvailableCoffeeTypes', (), _M_SmartHouse._t_CoffeeType) if 'TimeOfDay' not in _M_SmartHouse.__dict__: _M_SmartHouse.TimeOfDay = Ice.createTempClass() class TimeOfDay(object): def __init__(self, hour=0, minute=0, second=0): self.hour = hour self.minute = minute self.second = second def __hash__(self):
_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'): _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('_t_ReagentWellLinksSeq'): _M_omero.model._t_ReagentWellLinksSeq = IcePy.defineSequence('::omero::model::ReagentWellLinksSeq', (), _M_omero.model._t_WellReagentLink) if not _M_omero.model.__dict__.has_key('_t_ReagentLinkedWellSeq'): _M_omero.model._t_ReagentLinkedWellSeq = IcePy.defineSequence('::omero::model::ReagentLinkedWellSeq', (), _M_omero.model._t_Well) if not _M_omero.model.__dict__.has_key('_t_ReagentAnnotationLinksSeq'): _M_omero.model._t_ReagentAnnotationLinksSeq = IcePy.defineSequence('::omero::model::ReagentAnnotationLinksSeq', (), _M_omero.model._t_ReagentAnnotationLink) if not _M_omero.model.__dict__.has_key('_t_ReagentLinkedAnnotationSeq'): _M_omero.model._t_ReagentLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::ReagentLinkedAnnotationSeq', (), _M_omero.model._t_Annotation) if not _M_omero.model.__dict__.has_key('Reagent'): _M_omero.model.Reagent = Ice.createTempClass() class Reagent(_M_omero.model.IObject): def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _name=None, _reagentIdentifier=None, _screen=None, _wellLinksSeq=None, _wellLinksLoaded=False, _wellLinksCountPerOwner=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _description=None): if __builtin__.type(self) == _M_omero.model.Reagent:
_M_omero.api._t_ServiceInterfacePrx = IcePy.defineProxy( '::omero::api::ServiceInterface', ServiceInterfacePrx) _M_omero.api._t_ServiceInterface = IcePy.defineClass( '::omero::api::ServiceInterface', ServiceInterface, -1, (), True, False, None, (), ()) ServiceInterface._ice_type = _M_omero.api._t_ServiceInterface _M_omero.api.ServiceInterface = ServiceInterface del ServiceInterface _M_omero.api.ServiceInterfacePrx = ServiceInterfacePrx del ServiceInterfacePrx if '_t_ServiceList' not in _M_omero.api.__dict__: _M_omero.api._t_ServiceList = IcePy.defineSequence( '::omero::api::ServiceList', (), _M_omero.api._t_ServiceInterfacePrx) if 'StatefulServiceInterface' not in _M_omero.api.__dict__: _M_omero.api.StatefulServiceInterface = Ice.createTempClass() class StatefulServiceInterface(_M_omero.api.ServiceInterface): """ Service marker for stateful services which permits the closing of a particular service before the destruction of the session. """ def __init__(self): if Ice.getType(self) == _M_omero.api.StatefulServiceInterface: raise RuntimeError( 'omero.api.StatefulServiceInterface is an abstract class') def ice_ids(self, current=None):
__repr__ = __str__ _M_device_repo_ice._t_DeviceDisp = IcePy.defineClass( '::device_repo_ice::Device', Device, (), None, ()) Device._ice_type = _M_device_repo_ice._t_DeviceDisp Device._op_get_type = IcePy.Operation( 'get_type', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_device_repo_ice._t_DeviceType, False, 0), ()) _M_device_repo_ice.Device = Device del Device if '_t_DeviceEntries' not in _M_device_repo_ice.__dict__: _M_device_repo_ice._t_DeviceEntries = IcePy.defineSequence( '::device_repo_ice::DeviceEntries', (), _M_device_repo_ice._t_DeviceEntry) if 'InvalidTokenException' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.InvalidTokenException = Ice.createTempClass() class InvalidTokenException(Ice.UserException): def __init__(self): pass def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _ice_id = '::device_repo_ice::InvalidTokenException'
# Included module omero.model _M_omero.model = Ice.openModule('omero.model') # 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 not _M_omero.sys.__dict__.has_key('_t_LongList'): _M_omero.sys._t_LongList = IcePy.defineSequence('::omero::sys::LongList', (), IcePy._t_long) if not _M_omero.sys.__dict__.has_key('_t_IntList'): _M_omero.sys._t_IntList = IcePy.defineSequence('::omero::sys::IntList', (), IcePy._t_int) if not _M_omero.sys.__dict__.has_key('_t_CountMap'): _M_omero.sys._t_CountMap = IcePy.defineDictionary('::omero::sys::CountMap', (), IcePy._t_long, IcePy._t_long) if not _M_omero.sys.__dict__.has_key('_t_ParamMap'): _M_omero.sys._t_ParamMap = IcePy.defineDictionary('::omero::sys::ParamMap', (), IcePy._t_string, _M_omero._t_RType) if not _M_omero.sys.__dict__.has_key('_t_IdByteMap'): _M_omero.sys._t_IdByteMap = IcePy.defineDictionary('::omero::sys::IdByteMap', (), IcePy._t_long, _M_Ice._t_ByteSeq) if not _M_omero.sys.__dict__.has_key('EventContext'): _M_omero.sys.EventContext = Ice.createTempClass()