Python typecheck.is_enum函数代码示例

 def encode(ctxName, logLevel):
     typecheck.is_string(ctxName, AssertionError)
     typecheck.is_enum(logLevel, raritan.rpc.diag.DiagLogSettings.LogLevel, AssertionError)
     args = {}
     args['ctxName'] = ctxName
     args['logLevel'] = raritan.rpc.diag.DiagLogSettings.LogLevel.encode(logLevel)
     return args

    def __init__(self, enabled, autocfg, ipaddr, netmask, gateway, hostname, dns_suffixes, override_dns, dns_ip_1, dns_ip_2, domain_name):
        typecheck.is_bool(enabled, AssertionError)
        typecheck.is_enum(autocfg, raritan.rpc.net.AutoConfigs, AssertionError)
        typecheck.is_string(ipaddr, AssertionError)
        typecheck.is_string(netmask, AssertionError)
        typecheck.is_string(gateway, AssertionError)
        typecheck.is_string(hostname, AssertionError)
        for x0 in dns_suffixes:
            typecheck.is_string(x0, AssertionError)
        typecheck.is_bool(override_dns, AssertionError)
        typecheck.is_string(dns_ip_1, AssertionError)
        typecheck.is_string(dns_ip_2, AssertionError)
        typecheck.is_string(domain_name, AssertionError)

        self.enabled = enabled
        self.autocfg = autocfg
        self.ipaddr = ipaddr
        self.netmask = netmask
        self.gateway = gateway
        self.hostname = hostname
        self.dns_suffixes = dns_suffixes
        self.override_dns = override_dns
        self.dns_ip_1 = dns_ip_1
        self.dns_ip_2 = dns_ip_2
        self.domain_name = domain_name

 def startUpdate(self, flags):
     agent = self.agent
     for x0 in flags:
         typecheck.is_enum(x0, raritan.rpc.firmware.UpdateFlags, AssertionError)
     args = {}
     args['flags'] = [raritan.rpc.firmware.UpdateFlags.encode(x0) for x0 in flags]
     rsp = agent.json_rpc(self.target, 'startUpdate', args)

 def getState(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getState', args)
     _ret_ = raritan.rpc.hmi.ExternalBeeper.State.decode(rsp['_ret_'])
     typecheck.is_enum(_ret_, raritan.rpc.hmi.ExternalBeeper.State, DecodeException)
     return _ret_

    def __init__(self, width, height, pixelFormat):
        typecheck.is_int(width, AssertionError)
        typecheck.is_int(height, AssertionError)
        typecheck.is_enum(pixelFormat, raritan.rpc.webcam.PixelFormat, AssertionError)

        self.width = width
        self.height = height
        self.pixelFormat = pixelFormat

 def closeSession(self, token, reason):
     agent = self.agent
     typecheck.is_string(token, AssertionError)
     typecheck.is_enum(reason, raritan.rpc.session.SessionManager.CloseReason, AssertionError)
     args = {}
     args['token'] = token
     args['reason'] = raritan.rpc.session.SessionManager.CloseReason.encode(reason)
     rsp = agent.json_rpc(self.target, 'closeSession', args)

 def getSupportedStorageTypes(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getSupportedStorageTypes', args)
     _ret_ = [raritan.rpc.webcam.StorageManager.StorageType.decode(x0) for x0 in rsp['_ret_']]
     for x0 in _ret_:
         typecheck.is_enum(x0, raritan.rpc.webcam.StorageManager.StorageType, DecodeException)
     return _ret_

 def encode(refId, count, direction):
     typecheck.is_int(refId, AssertionError)
     typecheck.is_int(count, AssertionError)
     typecheck.is_enum(direction, raritan.rpc.logging.RangeDirection, AssertionError)
     args = {}
     args['refId'] = refId
     args['count'] = count
     args['direction'] = raritan.rpc.logging.RangeDirection.encode(direction)
     return args

 def getStatus(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getStatus', args)
     status = raritan.rpc.bulkcfg.BulkConfiguration.Status.decode(rsp['status'])
     timeStamp = raritan.rpc.Time.decode(rsp['timeStamp'])
     typecheck.is_enum(status, raritan.rpc.bulkcfg.BulkConfiguration.Status, DecodeException)
     typecheck.is_time(timeStamp, DecodeException)
     return (status, timeStamp)

 def getType(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getType', args)
     _ret_ = rsp['_ret_']
     type = raritan.rpc.cascading.Cascading.Type.decode(rsp['type'])
     typecheck.is_int(_ret_, DecodeException)
     typecheck.is_enum(type, raritan.rpc.cascading.Cascading.Type, DecodeException)
     return (_ret_, type)

 def setType(self, type):
     agent = self.agent
     typecheck.is_enum(type, raritan.rpc.cascading.Cascading.Type, AssertionError)
     args = {}
     args['type'] = raritan.rpc.cascading.Cascading.Type.encode(type)
     rsp = agent.json_rpc(self.target, 'setType', args)
     _ret_ = rsp['_ret_']
     typecheck.is_int(_ret_, DecodeException)
     return _ret_

 def setPowerState(self, state):
     agent = self.agent
     typecheck.is_enum(state, raritan.rpc.sensors.Sensor.OnOffState, AssertionError)
     args = {}
     args['state'] = raritan.rpc.sensors.Sensor.OnOffState.encode(state)
     rsp = agent.json_rpc(self.target, 'setPowerState', args)
     _ret_ = rsp['_ret_']
     typecheck.is_int(_ret_, DecodeException)
     return _ret_

        def __init__(self, zoneCfg, protocol, deviceTime, ntpCfg):
            typecheck.is_struct(zoneCfg, raritan.rpc.datetime.DateTime.ZoneCfg, AssertionError)
            typecheck.is_enum(protocol, raritan.rpc.datetime.DateTime.Protocol, AssertionError)
            typecheck.is_time(deviceTime, AssertionError)
            typecheck.is_struct(ntpCfg, raritan.rpc.datetime.DateTime.NtpCfg, AssertionError)

            self.zoneCfg = zoneCfg
            self.protocol = protocol
            self.deviceTime = deviceTime
            self.ntpCfg = ntpCfg

 def encode(webcam, start, count, direction):
     typecheck.is_interface(webcam, raritan.rpc.webcam.Webcam, AssertionError)
     typecheck.is_long(start, AssertionError)
     typecheck.is_int(count, AssertionError)
     typecheck.is_enum(direction, raritan.rpc.webcam.StorageManager.Direction, AssertionError)
     args = {}
     args['webcam'] = Interface.encode(webcam)
     args['start'] = start
     args['count'] = count
     args['direction'] = raritan.rpc.webcam.StorageManager.Direction.encode(direction)
     return args

    def __init__(self, state, error_message, time_started, size_total, size_done):
        typecheck.is_enum(state, raritan.rpc.firmware.ImageState, AssertionError)
        typecheck.is_string(error_message, AssertionError)
        typecheck.is_time(time_started, AssertionError)
        typecheck.is_int(size_total, AssertionError)
        typecheck.is_int(size_done, AssertionError)

        self.state = state
        self.error_message = error_message
        self.time_started = time_started
        self.size_total = size_total
        self.size_done = size_done