# 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):
_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
#
# 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()
