# -*- coding: utf-8 -*-
# **********************************************************************
#
# Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
#
# Ice version 3.6.3
#
# <auto-generated>
#
# Generated from file `obsControl.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
import Ice, IcePy
import sharknir_ice
import LbtoIIFInterface_ice

# Included module sharknir
_M_sharknir = Ice.openModule('sharknir')

# Included module lbto
_M_lbto = Ice.openModule('lbto')

# Start of module sharknir
__name__ = 'sharknir'

# Start of module sharknir.obsControl
_M_sharknir.obsControl = Ice.openModule('sharknir.obsControl')
__name__ = 'sharknir.obsControl'

if 'Sequencer' not in _M_sharknir.obsControl.__dict__:
    _M_sharknir.obsControl.Sequencer = Ice.createTempClass()
    class Sequencer(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_sharknir.obsControl.Sequencer:
                raise RuntimeError('sharknir.obsControl.Sequencer is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::sharknir::obsControl::Sequencer')

        def ice_id(self, current=None):
            return '::sharknir::obsControl::Sequencer'

        def ice_staticId():
            return '::sharknir::obsControl::Sequencer'
        ice_staticId = staticmethod(ice_staticId)

        def setupMotion(self, dictNonSci, strSetup, current=None):
            pass

        def setupMotionDict(self, dSetupPos, current=None):
            pass

        def initMotion(self, current=None):
            pass

        def setupTracking(self, strSetup, current=None):
            pass

        def setupCalibUnitDict(self, dSetupPos, current=None):
            pass

        def instrumentSetup(self, dSetupNamedPos, current=None):
            pass

        def emergencyAbort(self, current=None):
            pass

        def scicamExpose(self, dit, ndit, current=None):
            pass

        def scicamSaveFITS(self, current=None):
            pass

        def scicamGetFITSname(self, current=None):
            pass

        def BinocularControl(self, flag, current=None):
            pass

        def PresetTelescopeNoAO(self, target, guide, telescopeMode, current=None):
            pass

        def PresetTelescopeWithAO(self, target, guide, AOreference, telescopeMode, AOmode, current=None):
            pass

        def RunAO(self, mode, current=None):
            pass

        def SendWavefront(self, polynom, ope, current=None):
            pass

        def MoveFocus(self, ope, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_sharknir.obsControl._t_Sequencer)

        __repr__ = __str__

    _M_sharknir.obsControl.SequencerPrx = Ice.createTempClass()
    class SequencerPrx(Ice.ObjectPrx):

        def setupMotion(self, dictNonSci, strSetup, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupMotion.invoke(self, ((dictNonSci, strSetup), _ctx))

        def begin_setupMotion(self, dictNonSci, strSetup, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupMotion.begin(self, ((dictNonSci, strSetup), _response, _ex, _sent, _ctx))

        def end_setupMotion(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_setupMotion.end(self, _r)

        def setupMotionDict(self, dSetupPos, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupMotionDict.invoke(self, ((dSetupPos, ), _ctx))

        def begin_setupMotionDict(self, dSetupPos, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupMotionDict.begin(self, ((dSetupPos, ), _response, _ex, _sent, _ctx))

        def end_setupMotionDict(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_setupMotionDict.end(self, _r)

        def initMotion(self, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_initMotion.invoke(self, ((), _ctx))

        def begin_initMotion(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_initMotion.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_initMotion(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_initMotion.end(self, _r)

        def setupTracking(self, strSetup, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupTracking.invoke(self, ((strSetup, ), _ctx))

        def begin_setupTracking(self, strSetup, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupTracking.begin(self, ((strSetup, ), _response, _ex, _sent, _ctx))

        def end_setupTracking(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_setupTracking.end(self, _r)

        def setupCalibUnitDict(self, dSetupPos, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupCalibUnitDict.invoke(self, ((dSetupPos, ), _ctx))

        def begin_setupCalibUnitDict(self, dSetupPos, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_setupCalibUnitDict.begin(self, ((dSetupPos, ), _response, _ex, _sent, _ctx))

        def end_setupCalibUnitDict(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_setupCalibUnitDict.end(self, _r)

        def instrumentSetup(self, dSetupNamedPos, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_instrumentSetup.invoke(self, ((dSetupNamedPos, ), _ctx))

        def begin_instrumentSetup(self, dSetupNamedPos, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_instrumentSetup.begin(self, ((dSetupNamedPos, ), _response, _ex, _sent, _ctx))

        def end_instrumentSetup(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_instrumentSetup.end(self, _r)

        def emergencyAbort(self, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_emergencyAbort.invoke(self, ((), _ctx))

        def begin_emergencyAbort(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_emergencyAbort.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_emergencyAbort(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_emergencyAbort.end(self, _r)

        def scicamExpose(self, dit, ndit, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_scicamExpose.invoke(self, ((dit, ndit), _ctx))

        def begin_scicamExpose(self, dit, ndit, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_scicamExpose.begin(self, ((dit, ndit), _response, _ex, _sent, _ctx))

        def end_scicamExpose(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_scicamExpose.end(self, _r)

        def scicamSaveFITS(self, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_scicamSaveFITS.invoke(self, ((), _ctx))

        def begin_scicamSaveFITS(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_scicamSaveFITS.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_scicamSaveFITS(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_scicamSaveFITS.end(self, _r)

        def scicamGetFITSname(self, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_scicamGetFITSname.invoke(self, ((), _ctx))

        def begin_scicamGetFITSname(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_scicamGetFITSname.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_scicamGetFITSname(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_scicamGetFITSname.end(self, _r)

        def BinocularControl(self, flag, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_BinocularControl.invoke(self, ((flag, ), _ctx))

        def begin_BinocularControl(self, flag, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_BinocularControl.begin(self, ((flag, ), _response, _ex, _sent, _ctx))

        def end_BinocularControl(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_BinocularControl.end(self, _r)

        def PresetTelescopeNoAO(self, target, guide, telescopeMode, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_PresetTelescopeNoAO.invoke(self, ((target, guide, telescopeMode), _ctx))

        def begin_PresetTelescopeNoAO(self, target, guide, telescopeMode, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_PresetTelescopeNoAO.begin(self, ((target, guide, telescopeMode), _response, _ex, _sent, _ctx))

        def end_PresetTelescopeNoAO(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_PresetTelescopeNoAO.end(self, _r)

        def PresetTelescopeWithAO(self, target, guide, AOreference, telescopeMode, AOmode, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_PresetTelescopeWithAO.invoke(self, ((target, guide, AOreference, telescopeMode, AOmode), _ctx))

        def begin_PresetTelescopeWithAO(self, target, guide, AOreference, telescopeMode, AOmode, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_PresetTelescopeWithAO.begin(self, ((target, guide, AOreference, telescopeMode, AOmode), _response, _ex, _sent, _ctx))

        def end_PresetTelescopeWithAO(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_PresetTelescopeWithAO.end(self, _r)

        def RunAO(self, mode, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_RunAO.invoke(self, ((mode, ), _ctx))

        def begin_RunAO(self, mode, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_RunAO.begin(self, ((mode, ), _response, _ex, _sent, _ctx))

        def end_RunAO(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_RunAO.end(self, _r)

        def SendWavefront(self, polynom, ope, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_SendWavefront.invoke(self, ((polynom, ope), _ctx))

        def begin_SendWavefront(self, polynom, ope, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_SendWavefront.begin(self, ((polynom, ope), _response, _ex, _sent, _ctx))

        def end_SendWavefront(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_SendWavefront.end(self, _r)

        def MoveFocus(self, ope, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_MoveFocus.invoke(self, ((ope, ), _ctx))

        def begin_MoveFocus(self, ope, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.Sequencer._op_MoveFocus.begin(self, ((ope, ), _response, _ex, _sent, _ctx))

        def end_MoveFocus(self, _r):
            return _M_sharknir.obsControl.Sequencer._op_MoveFocus.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_sharknir.obsControl.SequencerPrx.ice_checkedCast(proxy, '::sharknir::obsControl::Sequencer', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_sharknir.obsControl.SequencerPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::sharknir::obsControl::Sequencer'
        ice_staticId = staticmethod(ice_staticId)

    _M_sharknir.obsControl._t_SequencerPrx = IcePy.defineProxy('::sharknir::obsControl::Sequencer', SequencerPrx)

    _M_sharknir.obsControl._t_Sequencer = IcePy.defineClass('::sharknir::obsControl::Sequencer', Sequencer, -1, (), True, False, None, (), ())
    Sequencer._ice_type = _M_sharknir.obsControl._t_Sequencer

    Sequencer._op_setupMotion = IcePy.Operation('setupMotion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_sharknir._t_dictNonSciAssembly, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_setupMotionDict = IcePy.Operation('setupMotionDict', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_sharknir._t_dictSetupPos, False, 0),), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_initMotion = IcePy.Operation('initMotion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_setupTracking = IcePy.Operation('setupTracking', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_setupCalibUnitDict = IcePy.Operation('setupCalibUnitDict', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_sharknir._t_dictSetupPos, False, 0),), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_instrumentSetup = IcePy.Operation('instrumentSetup', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_sharknir._t_dictSetupNamedPos, False, 0),), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_emergencyAbort = IcePy.Operation('emergencyAbort', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_scicamExpose = IcePy.Operation('scicamExpose', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0), ((), IcePy._t_int, False, 0)), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_scicamSaveFITS = IcePy.Operation('scicamSaveFITS', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_scicamGetFITSname = IcePy.Operation('scicamGetFITSname', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, None, (), (), (((), IcePy._t_string, False, 0),), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_BinocularControl = IcePy.Operation('BinocularControl', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_PresetTelescopeNoAO = IcePy.Operation('PresetTelescopeNoAO', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_lbto._t_position2, False, 0), ((), _M_lbto._t_position2, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_PresetTelescopeWithAO = IcePy.Operation('PresetTelescopeWithAO', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_lbto._t_position2, False, 0), ((), _M_lbto._t_position2, False, 0), ((), _M_lbto._t_position2, False, 0), ((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_RunAO = IcePy.Operation('RunAO', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_SendWavefront = IcePy.Operation('SendWavefront', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_lbto._t_SeqWF, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_int, False, 0), ())
    Sequencer._op_MoveFocus = IcePy.Operation('MoveFocus', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_int, False, 0), ())

    _M_sharknir.obsControl.Sequencer = Sequencer
    del Sequencer

    _M_sharknir.obsControl.SequencerPrx = SequencerPrx
    del SequencerPrx

if 'motionControl' not in _M_sharknir.obsControl.__dict__:
    _M_sharknir.obsControl.motionControl = Ice.createTempClass()
    class motionControl(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_sharknir.obsControl.motionControl:
                raise RuntimeError('sharknir.obsControl.motionControl is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::sharknir::obsControl::motionControl')

        def ice_id(self, current=None):
            return '::sharknir::obsControl::motionControl'

        def ice_staticId():
            return '::sharknir::obsControl::motionControl'
        ice_staticId = staticmethod(ice_staticId)

        def setupMotion(self, dictNonSci, strSetup, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_sharknir.obsControl._t_motionControl)

        __repr__ = __str__

    _M_sharknir.obsControl.motionControlPrx = Ice.createTempClass()
    class motionControlPrx(Ice.ObjectPrx):

        def setupMotion(self, dictNonSci, strSetup, _ctx=None):
            return _M_sharknir.obsControl.motionControl._op_setupMotion.invoke(self, ((dictNonSci, strSetup), _ctx))

        def begin_setupMotion(self, dictNonSci, strSetup, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.motionControl._op_setupMotion.begin(self, ((dictNonSci, strSetup), _response, _ex, _sent, _ctx))

        def end_setupMotion(self, _r):
            return _M_sharknir.obsControl.motionControl._op_setupMotion.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_sharknir.obsControl.motionControlPrx.ice_checkedCast(proxy, '::sharknir::obsControl::motionControl', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_sharknir.obsControl.motionControlPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::sharknir::obsControl::motionControl'
        ice_staticId = staticmethod(ice_staticId)

    _M_sharknir.obsControl._t_motionControlPrx = IcePy.defineProxy('::sharknir::obsControl::motionControl', motionControlPrx)

    _M_sharknir.obsControl._t_motionControl = IcePy.defineClass('::sharknir::obsControl::motionControl', motionControl, -1, (), True, False, None, (), ())
    motionControl._ice_type = _M_sharknir.obsControl._t_motionControl

    motionControl._op_setupMotion = IcePy.Operation('setupMotion', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, None, (), (((), _M_sharknir._t_dictNonSciAssembly, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_int, False, 0), ())

    _M_sharknir.obsControl.motionControl = motionControl
    del motionControl

    _M_sharknir.obsControl.motionControlPrx = motionControlPrx
    del motionControlPrx

if 'trackControl' not in _M_sharknir.obsControl.__dict__:
    _M_sharknir.obsControl.trackControl = Ice.createTempClass()
    class trackControl(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_sharknir.obsControl.trackControl:
                raise RuntimeError('sharknir.obsControl.trackControl is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::sharknir::obsControl::trackControl')

        def ice_id(self, current=None):
            return '::sharknir::obsControl::trackControl'

        def ice_staticId():
            return '::sharknir::obsControl::trackControl'
        ice_staticId = staticmethod(ice_staticId)

        def setupTracking(self, strSetup, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_sharknir.obsControl._t_trackControl)

        __repr__ = __str__

    _M_sharknir.obsControl.trackControlPrx = Ice.createTempClass()
    class trackControlPrx(Ice.ObjectPrx):

        def setupTracking(self, strSetup, _ctx=None):
            return _M_sharknir.obsControl.trackControl._op_setupTracking.invoke(self, ((strSetup, ), _ctx))

        def begin_setupTracking(self, strSetup, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.trackControl._op_setupTracking.begin(self, ((strSetup, ), _response, _ex, _sent, _ctx))

        def end_setupTracking(self, _r):
            return _M_sharknir.obsControl.trackControl._op_setupTracking.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_sharknir.obsControl.trackControlPrx.ice_checkedCast(proxy, '::sharknir::obsControl::trackControl', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_sharknir.obsControl.trackControlPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::sharknir::obsControl::trackControl'
        ice_staticId = staticmethod(ice_staticId)

    _M_sharknir.obsControl._t_trackControlPrx = IcePy.defineProxy('::sharknir::obsControl::trackControl', trackControlPrx)

    _M_sharknir.obsControl._t_trackControl = IcePy.defineClass('::sharknir::obsControl::trackControl', trackControl, -1, (), True, False, None, (), ())
    trackControl._ice_type = _M_sharknir.obsControl._t_trackControl

    trackControl._op_setupTracking = IcePy.Operation('setupTracking', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_int, False, 0), ())

    _M_sharknir.obsControl.trackControl = trackControl
    del trackControl

    _M_sharknir.obsControl.trackControlPrx = trackControlPrx
    del trackControlPrx

if 'calibrationControl' not in _M_sharknir.obsControl.__dict__:
    _M_sharknir.obsControl.calibrationControl = Ice.createTempClass()
    class calibrationControl(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_sharknir.obsControl.calibrationControl:
                raise RuntimeError('sharknir.obsControl.calibrationControl is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::sharknir::obsControl::calibrationControl')

        def ice_id(self, current=None):
            return '::sharknir::obsControl::calibrationControl'

        def ice_staticId():
            return '::sharknir::obsControl::calibrationControl'
        ice_staticId = staticmethod(ice_staticId)

        def setupCalibration(self, dictNonSci, strSetup, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_sharknir.obsControl._t_calibrationControl)

        __repr__ = __str__

    _M_sharknir.obsControl.calibrationControlPrx = Ice.createTempClass()
    class calibrationControlPrx(Ice.ObjectPrx):

        def setupCalibration(self, dictNonSci, strSetup, _ctx=None):
            return _M_sharknir.obsControl.calibrationControl._op_setupCalibration.invoke(self, ((dictNonSci, strSetup), _ctx))

        def begin_setupCalibration(self, dictNonSci, strSetup, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_sharknir.obsControl.calibrationControl._op_setupCalibration.begin(self, ((dictNonSci, strSetup), _response, _ex, _sent, _ctx))

        def end_setupCalibration(self, _r):
            return _M_sharknir.obsControl.calibrationControl._op_setupCalibration.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_sharknir.obsControl.calibrationControlPrx.ice_checkedCast(proxy, '::sharknir::obsControl::calibrationControl', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_sharknir.obsControl.calibrationControlPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::sharknir::obsControl::calibrationControl'
        ice_staticId = staticmethod(ice_staticId)

    _M_sharknir.obsControl._t_calibrationControlPrx = IcePy.defineProxy('::sharknir::obsControl::calibrationControl', calibrationControlPrx)

    _M_sharknir.obsControl._t_calibrationControl = IcePy.defineClass('::sharknir::obsControl::calibrationControl', calibrationControl, -1, (), True, False, None, (), ())
    calibrationControl._ice_type = _M_sharknir.obsControl._t_calibrationControl

    calibrationControl._op_setupCalibration = IcePy.Operation('setupCalibration', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, None, (), (((), _M_sharknir._t_dictNonSciAssembly, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_int, False, 0), ())

    _M_sharknir.obsControl.calibrationControl = calibrationControl
    del calibrationControl

    _M_sharknir.obsControl.calibrationControlPrx = calibrationControlPrx
    del calibrationControlPrx

# End of module sharknir.obsControl

__name__ = 'sharknir'

# End of module sharknir
