# Generated from file `bidirectional.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module Demo
_M_Demo = Ice.openModule('Demo')
__name__ = 'Demo'
_M_Demo._t_PrinterPython = IcePy.defineValue('::Demo::PrinterPython',
Ice.Value, -1, (), False, True,
None, ())
if 'PrinterPythonPrx' not in _M_Demo.__dict__:
_M_Demo.PrinterPythonPrx = Ice.createTempClass()
class PrinterPythonPrx(Ice.ObjectPrx):
def PrintString(self, s, context=None):
return _M_Demo.PrinterPython._op_PrintString.invoke(
self, ((s, ), context))
def PrintStringAsync(self, s, context=None):
return _M_Demo.PrinterPython._op_PrintString.invokeAsync(
self, ((s, ), context))
def begin_PrintString(self,
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::SmartHouse::LackOfIngredientExc'
_M_SmartHouse._t_LackOfIngredientExc = IcePy.defineException(
'::SmartHouse::LackOfIngredientExc', LackOfIngredientExc, (), False,
_M_SmartHouse._t_DeviceError, ())
LackOfIngredientExc._ice_type = _M_SmartHouse._t_LackOfIngredientExc
_M_SmartHouse.LackOfIngredientExc = LackOfIngredientExc
del LackOfIngredientExc
_M_SmartHouse._t_ISmartDevice = IcePy.defineValue('::SmartHouse::ISmartDevice',
Ice.Value, -1, (), False,
True, None, ())
if 'ISmartDevicePrx' not in _M_SmartHouse.__dict__:
_M_SmartHouse.ISmartDevicePrx = Ice.createTempClass()
class ISmartDevicePrx(Ice.ObjectPrx):
def getPowerMode(self, context=None):
return _M_SmartHouse.ISmartDevice._op_getPowerMode.invoke(
self, ((), context))
def getPowerModeAsync(self, context=None):
return _M_SmartHouse.ISmartDevice._op_getPowerMode.invokeAsync(
self, ((), context))
def begin_getPowerMode(self,
('s6', (), IcePy._t_string), ('s7', (), IcePy._t_string),
('s8', (), IcePy._t_string), ('d3', (), IcePy._t_double),
('d4', (), IcePy._t_double), ('d5', (), IcePy._t_double),
('b3', (), IcePy._t_bool), ('b4',
(), IcePy._t_bool), ('b5',
(), IcePy._t_bool),
('iSeq2', (), _M_Tester._t_SeqInt), ('sSeq2',
(), _M_Tester._t_SeqString),
('dSeq1', (), _M_Tester._t_SeqDouble), ('dSeq2',
(), _M_Tester._t_SeqDouble)))
_M_Tester.BigData = BigData
del BigData
_M_Tester._t_TesterIface = IcePy.defineValue('::Tester::TesterIface',
Ice.Value, -1, (), False, True,
None, ())
if 'TesterIfacePrx' not in _M_Tester.__dict__:
_M_Tester.TesterIfacePrx = Ice.createTempClass()
class TesterIfacePrx(Ice.ObjectPrx):
def processSmall(self, smallData, context=None):
return _M_Tester.TesterIface._op_processSmall.invoke(
self, ((smallData, ), context))
def processSmallAsync(self, smallData, context=None):
return _M_Tester.TesterIface._op_processSmall.invokeAsync(
self, ((smallData, ), context))
def begin_processSmall(self,
Perform any necessary initialization steps.
"""
raise NotImplementedError("method 'initialize' not implemented")
def destroy(self):
"""
Called when the communicator is being destroyed.
"""
raise NotImplementedError("method 'destroy' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice._t_Plugin)
__repr__ = __str__
_M_Ice._t_Plugin = IcePy.defineValue('::Ice::Plugin', Plugin, -1, (), False, True, None, ())
Plugin._ice_type = _M_Ice._t_Plugin
_M_Ice.Plugin = Plugin
del Plugin
if 'PluginManager' not in _M_Ice.__dict__:
_M_Ice.PluginManager = Ice.createTempClass()
class PluginManager(object):
"""
Each communicator has a plug-in manager to administer the set of
plug-ins.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.PluginManager:
raise RuntimeError('Ice.PluginManager is an abstract class')
Arguments:
curr -- Information about the current operation call for which a servant was located by locate.
servant -- The servant that was returned by locate.
cookie -- The cookie that was returned by locate.
Throws:
UserException -- The implementation can raise a UserException and the run time will marshal it as the result of the invocation.
"""
raise NotImplementedError("method 'finished' not implemented")
def deactivate(self, category):
"""
Called when the object adapter in which this servant locator is
installed is destroyed.
Arguments:
category -- Indicates for which category the servant locator is being deactivated.
"""
raise NotImplementedError("method 'deactivate' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice._t_ServantLocator)
__repr__ = __str__
_M_Ice._t_ServantLocator = IcePy.defineValue('::Ice::ServantLocator', ServantLocator, -1, (), False, True, None, ())
ServantLocator._ice_type = _M_Ice._t_ServantLocator
_M_Ice.ServantLocator = ServantLocator
del ServantLocator
# End of module Ice
#
from sys import version_info as _version_info_
import Ice, IcePy
import Ice.BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
if '_t_PropertyDict' not in _M_Ice.__dict__:
_M_Ice._t_PropertyDict = IcePy.defineDictionary('::Ice::PropertyDict', (), IcePy._t_string, IcePy._t_string)
_M_Ice._t_PropertiesAdmin = IcePy.defineValue('::Ice::PropertiesAdmin', Ice.Value, -1, (), False, True, None, ())
if 'PropertiesAdminPrx' not in _M_Ice.__dict__:
_M_Ice.PropertiesAdminPrx = Ice.createTempClass()
class PropertiesAdminPrx(Ice.ObjectPrx):
"""
Get a property by key. If the property is not set, an empty
string is returned.
Arguments:
key -- The property key.
context -- The request context for the invocation.
Returns: The property value.
"""
def getProperty(self, key, context=None):
return _M_Ice.PropertiesAdmin._op_getProperty.invoke(self, ((key, ), context))
"""
raise NotImplementedError("method 'parseIceCommandLineOptions' not implemented")
def load(self, file):
"""
Load properties from a file.
Arguments:
file -- The property file.
"""
raise NotImplementedError("method 'load' not implemented")
def clone(self):
"""
Create a copy of this property set.
Returns: A copy of this property set.
"""
raise NotImplementedError("method 'clone' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice._t_Properties)
__repr__ = __str__
_M_Ice._t_Properties = IcePy.defineValue('::Ice::Properties', Properties, -1, (), False, True, None, ())
Properties._ice_type = _M_Ice._t_Properties
_M_Ice.Properties = Properties
del Properties
# End of module Ice
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::SmartHouse::IsOffError'
_M_SmartHouse._t_IsOffError = IcePy.defineException(
'::SmartHouse::IsOffError', IsOffError, (), False,
_M_SmartHouse._t_Error, ())
IsOffError._ice_type = _M_SmartHouse._t_IsOffError
_M_SmartHouse.IsOffError = IsOffError
del IsOffError
_M_SmartHouse._t_IDevice = IcePy.defineValue('::SmartHouse::IDevice',
Ice.Value, -1, (), False, True,
None, ())
if 'IDevicePrx' not in _M_SmartHouse.__dict__:
_M_SmartHouse.IDevicePrx = Ice.createTempClass()
class IDevicePrx(Ice.ObjectPrx):
def getPowerState(self, context=None):
return _M_SmartHouse.IDevice._op_getPowerState.invoke(
self, ((), context))
def getPowerStateAsync(self, context=None):
return _M_SmartHouse.IDevice._op_getPowerState.invokeAsync(
self, ((), context))
def begin_getPowerState(self,
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
from . import device_repo_ice
# Included module device_repo_ice
_M_device_repo_ice = Ice.openModule('device_repo.device_repo_ice')
# Start of module device_repo_ice
__name__ = 'device_repo.device_repo_ice'
_M_device_repo_ice._t_Digitizer = IcePy.defineValue(
'::device_repo_ice::Digitizer', Ice.Value, -1, (), False, True, None, ())
if 'DigitizerPrx' not in _M_device_repo_ice.__dict__:
_M_device_repo_ice.DigitizerPrx = Ice.createTempClass()
class DigitizerPrx(_M_device_repo_ice.DevicePrx):
def set_sample_number(self, number_of_samples, context=None):
return _M_device_repo_ice.Digitizer._op_set_sample_number.invoke(
self, ((number_of_samples, ), context))
def set_sample_numberAsync(self, number_of_samples, context=None):
return _M_device_repo_ice.Digitizer._op_set_sample_number.invokeAsync(
self, ((number_of_samples, ), context))
def begin_set_sample_number(self,
number_of_samples,
('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(
self, ((ciudad, ), context))
def reporteSemanalAsync(self, ciudad, context=None):
return _M_Meteorologia.Conexion._op_reporteSemanal.invokeAsync(
self, ((ciudad, ), context))
def begin_reporteSemanal(self,
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::AlreadyCreated'
_M_Bank._t_AlreadyCreated = IcePy.defineException('::Bank::AlreadyCreated',
AlreadyCreated, (),
False, None, ())
AlreadyCreated._ice_type = _M_Bank._t_AlreadyCreated
_M_Bank.AlreadyCreated = AlreadyCreated
del AlreadyCreated
_M_Bank._t_Account = IcePy.defineValue('::Bank::Account', Ice.Value, -1, (),
False, True, None, ())
if 'AccountPrx' not in _M_Bank.__dict__:
_M_Bank.AccountPrx = Ice.createTempClass()
class AccountPrx(Ice.ObjectPrx):
def getCreditCost(self, amount, finishDate, context=None):
return _M_Bank.Account._op_getCreditCost.invoke(
self, ((amount, finishDate), context))
def getCreditCostAsync(self, amount, finishDate, context=None):
return _M_Bank.Account._op_getCreditCost.invokeAsync(
self, ((amount, finishDate), context))
def begin_getCreditCost(self,
amount,
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Glacier2::PermissionDeniedException'
_M_Glacier2._t_PermissionDeniedException = IcePy.defineException('::Glacier2::PermissionDeniedException', PermissionDeniedException, (), True, None, (('reason', (), IcePy._t_string, False, 0),))
PermissionDeniedException._ice_type = _M_Glacier2._t_PermissionDeniedException
_M_Glacier2.PermissionDeniedException = PermissionDeniedException
del PermissionDeniedException
_M_Glacier2._t_PermissionsVerifier = IcePy.defineValue('::Glacier2::PermissionsVerifier', Ice.Value, -1, (), False, True, None, ())
if 'PermissionsVerifierPrx' not in _M_Glacier2.__dict__:
_M_Glacier2.PermissionsVerifierPrx = Ice.createTempClass()
class PermissionsVerifierPrx(Ice.ObjectPrx):
"""
Check whether a user has permission to access the router.
Arguments:
userId -- The user id for which to check permission.
password -- The user's password.
context -- The request context for the invocation.
Returns a tuple containing the following:
_retval -- True if access is granted, or false otherwise.
reason -- The reason why access was denied.
Throws:
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
from . import device_repo_ice
# Included module device_repo_ice
_M_device_repo_ice = Ice.openModule('device_repo.device_repo_ice')
# Start of module device_repo_ice
__name__ = 'device_repo.device_repo_ice'
_M_device_repo_ice._t_DummyDevice = IcePy.defineValue(
'::device_repo_ice::DummyDevice', Ice.Value, -1, (), False, True, None, ())
if 'DummyDevicePrx' not in _M_device_repo_ice.__dict__:
_M_device_repo_ice.DummyDevicePrx = Ice.createTempClass()
class DummyDevicePrx(_M_device_repo_ice.DevicePrx):
def get_data(self, context=None):
return _M_device_repo_ice.DummyDevice._op_get_data.invoke(
self, ((), context))
def get_dataAsync(self, context=None):
return _M_device_repo_ice.DummyDevice._op_get_data.invokeAsync(
self, ((), context))
def begin_get_data(self,
_response=None,
def failed(self, exceptionName):
"""
Notification of a failure.
Arguments:
exceptionName -- The name of the exception.
"""
raise NotImplementedError("method 'failed' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice.Instrumentation._t_Observer)
__repr__ = __str__
_M_Ice.Instrumentation._t_Observer = IcePy.defineValue(
'::Ice::Instrumentation::Observer', Observer, -1, (), False, True,
None, ())
Observer._ice_type = _M_Ice.Instrumentation._t_Observer
_M_Ice.Instrumentation.Observer = Observer
del Observer
if 'ThreadState' not in _M_Ice.Instrumentation.__dict__:
_M_Ice.Instrumentation.ThreadState = Ice.createTempClass()
class ThreadState(Ice.EnumBase):
"""
The thread state enumeration keeps track of the different possible
states of Ice threads.
Enumerators:
ThreadStateIdle -- The thread is idle.
__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))
def begin_sendPlayList(self,
seq,
unnamed top-level Slice module. For example, the absolute
Slice type id for an interface Bar in the module
Foo is "::Foo::Bar".
Note that the leading "::" is required.
Arguments:
type -- The value type.
Returns: The value created for the given type, or nil if the factory is unable to create the value.
"""
raise NotImplementedError("method 'create' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice._t_ValueFactory)
__repr__ = __str__
_M_Ice._t_ValueFactory = IcePy.defineValue('::Ice::ValueFactory', ValueFactory, -1, (), False, True, None, ())
ValueFactory._ice_type = _M_Ice._t_ValueFactory
_M_Ice.ValueFactory = ValueFactory
del ValueFactory
if 'ValueFactoryManager' not in _M_Ice.__dict__:
_M_Ice.ValueFactoryManager = Ice.createTempClass()
class ValueFactoryManager(object):
"""
A value factory manager maintains a collection of value factories.
An application can supply a custom implementation during communicator
initialization, otherwise Ice provides a default implementation.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.ValueFactoryManager:
__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))
def begin_ajouterMusique(self,
name,
_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(
self, ((result, ), context))
def begin_singleNotify(self,
else:
return r != 0
def __str__(self):
return IcePy.stringify(self, _M_Bank._t_UserCredentials)
__repr__ = __str__
_M_Bank._t_UserCredentials = IcePy.defineStruct(
'::Bank::UserCredentials', UserCredentials, (),
(('pesel', (), IcePy._t_string), ('password', (), IcePy._t_string)))
_M_Bank.UserCredentials = UserCredentials
del UserCredentials
_M_Bank._t_Account = IcePy.defineValue('::Bank::Account', Ice.Value, -1, (),
False, True, None, ())
if 'AccountPrx' not in _M_Bank.__dict__:
_M_Bank.AccountPrx = Ice.createTempClass()
class AccountPrx(Ice.ObjectPrx):
def getCurrentState(self, credentials, context=None):
return _M_Bank.Account._op_getCurrentState.invoke(
self, ((credentials, ), context))
def getCurrentStateAsync(self, credentials, context=None):
return _M_Bank.Account._op_getCurrentState.invokeAsync(
self, ((credentials, ), context))
def begin_getCurrentState(self,
credentials,
self.forwarded = forwarded
def ice_id(self):
return '::IceMX::TopicMetrics'
@staticmethod
def ice_staticId():
return '::IceMX::TopicMetrics'
def __str__(self):
return IcePy.stringify(self, _M_IceMX._t_TopicMetrics)
__repr__ = __str__
_M_IceMX._t_TopicMetrics = IcePy.defineValue(
'::IceMX::TopicMetrics', TopicMetrics, -1, (), False, False,
_M_IceMX._t_Metrics, (('published', (), IcePy._t_long, False, 0),
('forwarded', (), IcePy._t_long, False, 0)))
TopicMetrics._ice_type = _M_IceMX._t_TopicMetrics
_M_IceMX.TopicMetrics = TopicMetrics
del TopicMetrics
if 'SubscriberMetrics' not in _M_IceMX.__dict__:
_M_IceMX.SubscriberMetrics = Ice.createTempClass()
class SubscriberMetrics(_M_IceMX.Metrics):
"""
Provides information on IceStorm subscribers.
Members:
queued -- Number of queued events.
outstanding -- Number of outstanding events.
__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(
self, ((name, author, album), context))
def begin_searchMusic(self,
return IcePy.stringify(self, _M_filecenter._t_FileInfo)
__repr__ = __str__
_M_filecenter._t_FileInfo = IcePy.defineStruct(
'::filecenter::FileInfo', FileInfo, (),
(('creattime', (), IcePy._t_long), ('updatetime', (), IcePy._t_long),
('filesize', (), IcePy._t_int), ('filescore', (), IcePy._t_byte),
('filename', (), IcePy._t_string), ('filetype', (), IcePy._t_string),
('filepath', (), IcePy._t_string)))
_M_filecenter.FileInfo = FileInfo
del FileInfo
_M_filecenter._t_FileReader = IcePy.defineValue('::filecenter::FileReader',
Ice.Value, -1, (), False, True,
None, ())
if 'FileReaderPrx' not in _M_filecenter.__dict__:
_M_filecenter.FileReaderPrx = Ice.createTempClass()
class FileReaderPrx(Ice.ObjectPrx):
def ReadFileInfo(self, fileid, context=None):
return _M_filecenter.FileReader._op_ReadFileInfo.invoke(
self, ((fileid, ), context))
def ReadFileInfoAsync(self, fileid, context=None):
return _M_filecenter.FileReader._op_ReadFileInfo.invokeAsync(
self, ((fileid, ), context))
def begin_ReadFileInfo(self,
# Generated from file `PetFood.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module PetFoodSensors
_M_PetFoodSensors = Ice.openModule('PetFoodSensors')
__name__ = 'PetFoodSensors'
_M_PetFoodSensors._t_SensorControl = IcePy.defineValue(
'::PetFoodSensors::SensorControl', Ice.Value, -1, (), False, True, None,
())
if 'SensorControlPrx' not in _M_PetFoodSensors.__dict__:
_M_PetFoodSensors.SensorControlPrx = Ice.createTempClass()
class SensorControlPrx(Ice.ObjectPrx):
def motorTime(self, time, context=None):
return _M_PetFoodSensors.SensorControl._op_motorTime.invoke(
self, ((time, ), context))
def motorTimeAsync(self, time, context=None):
return _M_PetFoodSensors.SensorControl._op_motorTime.invokeAsync(
self, ((time, ), context))
def begin_motorTime(self,
#
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))
def begin_recognitionRadar(self, r, _response=None, _ex=None, _sent=None, context=None):
return _M_xidianRadar.RadarUtil._op_recognitionRadar.begin(self, ((r, ), _response, _ex, _sent, context))
def end_recognitionRadar(self, _r):
"""
Returns true if this endpoint is a secure endpoint.
Returns: True for a secure endpoint.
"""
raise NotImplementedError("method 'secure' not implemented")
def __str__(self):
return IcePy.stringify(self, _M_Ice._t_EndpointInfo)
__repr__ = __str__
_M_Ice._t_EndpointInfo = IcePy.declareValue('::Ice::EndpointInfo')
_M_Ice._t_EndpointInfo = IcePy.defineValue('::Ice::EndpointInfo', EndpointInfo, -1, (), False, False, None, (
('underlying', (), _M_Ice._t_EndpointInfo, False, 0),
('timeout', (), IcePy._t_int, False, 0),
('compress', (), IcePy._t_bool, False, 0)
))
EndpointInfo._ice_type = _M_Ice._t_EndpointInfo
_M_Ice.EndpointInfo = EndpointInfo
del EndpointInfo
if 'Endpoint' not in _M_Ice.__dict__:
_M_Ice.Endpoint = Ice.createTempClass()
class Endpoint(object):
"""
The user-level interface to an endpoint.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Endpoint:
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
from . import device_repo_ice
# Included module device_repo_ice
_M_device_repo_ice = Ice.openModule('device_repo.device_repo_ice')
# Start of module device_repo_ice
__name__ = 'device_repo.device_repo_ice'
_M_device_repo_ice._t_VNA = IcePy.defineValue('::device_repo_ice::VNA', Ice.Value, -1, (), False, True, None, ())
if 'VNAPrx' not in _M_device_repo_ice.__dict__:
_M_device_repo_ice.VNAPrx = Ice.createTempClass()
class VNAPrx(_M_device_repo_ice.DevicePrx):
def set_power(self, power_in_db, context=None):
return _M_device_repo_ice.VNA._op_set_power.invoke(self, ((power_in_db, ), context))
def set_powerAsync(self, power_in_db, context=None):
return _M_device_repo_ice.VNA._op_set_power.invokeAsync(self, ((power_in_db, ), context))
def begin_set_power(self, power_in_db, _response=None, _ex=None, _sent=None, context=None):
return _M_device_repo_ice.VNA._op_set_power.begin(self, ((power_in_db, ), _response, _ex, _sent, context))
def end_set_power(self, _r):
import Glacier2.Session_ice
import IceGrid.Exception_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Included module Glacier2
_M_Glacier2 = Ice.openModule('Glacier2')
# Included module IceGrid
_M_IceGrid = Ice.openModule('IceGrid')
# Start of module IceGrid
__name__ = 'IceGrid'
_M_IceGrid._t_Session = IcePy.defineValue('::IceGrid::Session', Ice.Value, -1, (), False, True, None, ())
if 'SessionPrx' not in _M_IceGrid.__dict__:
_M_IceGrid.SessionPrx = Ice.createTempClass()
class SessionPrx(_M_Glacier2.SessionPrx):
"""
Keep the session alive. Clients should call this operation
regularly to prevent the server from reaping the session.
Arguments:
context -- The request context for the invocation.
"""
def keepAlive(self, context=None):
return _M_IceGrid.Session._op_keepAlive.invoke(self, ((), context))
"""
__repr__ = __str__
_M_Server._t_Song = IcePy.defineStruct('::Server::Song', Song, (), (
('name', (), IcePy._t_string),
('author', (), IcePy._t_string),
('album', (), IcePy._t_string),
('path', (), IcePy._t_string)
))
_M_Server.Song = Song
del Song
if '_t_SongSeq' not in _M_Server.__dict__:
_M_Server._t_SongSeq = IcePy.defineSequence('::Server::SongSeq', (), _M_Server._t_Song)
_M_Server._t_IServer = IcePy.defineValue('::Server::IServer', Ice.Value, -1, (), False, True, None, ())
if 'IServerPrx' not in _M_Server.__dict__:
_M_Server.IServerPrx = Ice.createTempClass()
class IServerPrx(Ice.ObjectPrx):
def searchMusic(self, name, author, album, context=None):
return _M_Server.IServer._op_searchMusic.invoke(self, ((name, author, album), context))
def searchMusicAsync(self, name, author, album, context=None):
return _M_Server.IServer._op_searchMusic.invokeAsync(self, ((name, author, album), context))
def begin_searchMusic(self, name, author, album, _response=None, _ex=None, _sent=None, context=None):
return _M_Server.IServer._op_searchMusic.begin(self, ((name, author, album), _response, _ex, _sent, context))
def end_searchMusic(self, _r):
def __str__(self):
return IcePy.stringify(self, _M_device_repo_ice._t_DeviceEntry)
__repr__ = __str__
_M_device_repo_ice._t_DeviceEntry = IcePy.defineStruct(
'::device_repo_ice::DeviceEntry', DeviceEntry, (),
(('id', (), IcePy._t_string), ('type',
(), _M_device_repo_ice._t_DeviceType)))
_M_device_repo_ice.DeviceEntry = DeviceEntry
del DeviceEntry
_M_device_repo_ice._t_Device = IcePy.defineValue('::device_repo_ice::Device',
Ice.Value, -1, (), False,
True, None, ())
if 'DevicePrx' not in _M_device_repo_ice.__dict__:
_M_device_repo_ice.DevicePrx = Ice.createTempClass()
class DevicePrx(Ice.ObjectPrx):
def get_type(self, context=None):
return _M_device_repo_ice.Device._op_get_type.invoke(
self, ((), context))
def get_typeAsync(self, context=None):
return _M_device_repo_ice.Device._op_get_type.invokeAsync(
self, ((), context))
def begin_get_type(self,
def ice_id(self):
return '::StreamingServer::Track'
@staticmethod
def ice_staticId():
return '::StreamingServer::Track'
def __str__(self):
return IcePy.stringify(self, _M_StreamingServer._t_Track)
__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):
