text: #
  # Autogenerated by Thrift Compiler (0.8.0)
  #
  # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  #
  #  options string: py
  #
  
  from thrift.Thrift import TType, TMessageType, TException
  from ttypes import *
  from thrift.Thrift import TProcessor
  from thrift.transport import TTransport
  from thrift.protocol import TBinaryProtocol, TProtocol
  try:
    from thrift.protocol import fastbinary
  except:
    fastbinary = None
  
  
  class Iface:
    def queryLogs(self, query):
      """
      Parameters:
       - query
      """
      pass
  
    def query(self, query):
      """
      Parameters:
       - query
      """
      pass
  
    def fetchSensor(self, name):
      """
      Parameters:
       - name
      """
      pass
  
    def sensorHash(self, name):
      """
      Parameters:
       - name
      """
      pass
  
    def deploySensor(self, name, file):
      """
      Parameters:
       - name
       - file
      """
      pass
  
    def getAllSensors(self, ):
      pass
  
    def hasBinary(self, sensor):
      """
      Parameters:
       - sensor
      """
      pass
  
    def getSensorLabels(self, sensor):
      """
      Parameters:
       - sensor
      """
      pass
  
    def delSensor(self, sensor):
      """
      Parameters:
       - sensor
      """
      pass
  
    def setSensorLabels(self, sensor, labels):
      """
      Parameters:
       - sensor
       - labels
      """
      pass
  
    def setSensorConfiguration(self, sensor, configuration):
      """
      Parameters:
       - sensor
       - configuration
      """
      pass
  
    def getSensorConfiguration(self, sensor):
      """
      Parameters:
       - sensor
      """
      pass
  
    def getSensorNames(self, ):
      pass
  
    def addHost(self, hostname):
      """
      Parameters:
       - hostname
      """
      pass
  
    def addHostExtension(self, hostname, virtualHostName):
      """
      Parameters:
       - hostname
       - virtualHostName
      """
      pass
  
    def getHostExtension(self, hostname):
      """
      Parameters:
       - hostname
      """
      pass
  
    def getAllHosts(self, ):
      pass
  
    def delHost(self, hostname):
      """
      Parameters:
       - hostname
      """
      pass
  
    def setHostLabels(self, hostname, labels):
      """
      Parameters:
       - hostname
       - labels
      """
      pass
  
    def getLabels(self, hostname):
      """
      Parameters:
       - hostname
      """
      pass
  
    def setSensor(self, hostname, sensor, activate):
      """
      Parameters:
       - hostname
       - sensor
       - activate
      """
      pass
  
    def getSensors(self, hostname):
      """
      Parameters:
       - hostname
      """
      pass
  
    def getBundledSensorConfiguration(self, sensor, hostname):
      """
      Parameters:
       - sensor
       - hostname
      """
      pass
  
  
  class Client(Iface):
    def __init__(self, iprot, oprot=None):
      self._iprot = self._oprot = iprot
      if oprot is not None:
        self._oprot = oprot
      self._seqid = 0
  
    def queryLogs(self, query):
      """
      Parameters:
       - query
      """
      self.send_queryLogs(query)
      return self.recv_queryLogs()
  
    def send_queryLogs(self, query):
      self._oprot.writeMessageBegin('queryLogs', TMessageType.CALL, self._seqid)
      args = queryLogs_args()
      args.query = query
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_queryLogs(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = queryLogs_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "queryLogs failed: unknown result");
  
    def query(self, query):
      """
      Parameters:
       - query
      """
      self.send_query(query)
      return self.recv_query()
  
    def send_query(self, query):
      self._oprot.writeMessageBegin('query', TMessageType.CALL, self._seqid)
      args = query_args()
      args.query = query
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_query(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = query_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "query failed: unknown result");
  
    def fetchSensor(self, name):
      """
      Parameters:
       - name
      """
      self.send_fetchSensor(name)
      return self.recv_fetchSensor()
  
    def send_fetchSensor(self, name):
      self._oprot.writeMessageBegin('fetchSensor', TMessageType.CALL, self._seqid)
      args = fetchSensor_args()
      args.name = name
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_fetchSensor(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = fetchSensor_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchSensor failed: unknown result");
  
    def sensorHash(self, name):
      """
      Parameters:
       - name
      """
      self.send_sensorHash(name)
      return self.recv_sensorHash()
  
    def send_sensorHash(self, name):
      self._oprot.writeMessageBegin('sensorHash', TMessageType.CALL, self._seqid)
      args = sensorHash_args()
      args.name = name
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_sensorHash(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = sensorHash_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "sensorHash failed: unknown result");
  
    def deploySensor(self, name, file):
      """
      Parameters:
       - name
       - file
      """
      self.send_deploySensor(name, file)
      self.recv_deploySensor()
  
    def send_deploySensor(self, name, file):
      self._oprot.writeMessageBegin('deploySensor', TMessageType.CALL, self._seqid)
      args = deploySensor_args()
      args.name = name
      args.file = file
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_deploySensor(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = deploySensor_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def getAllSensors(self, ):
      self.send_getAllSensors()
      return self.recv_getAllSensors()
  
    def send_getAllSensors(self, ):
      self._oprot.writeMessageBegin('getAllSensors', TMessageType.CALL, self._seqid)
      args = getAllSensors_args()
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getAllSensors(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getAllSensors_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSensors failed: unknown result");
  
    def hasBinary(self, sensor):
      """
      Parameters:
       - sensor
      """
      self.send_hasBinary(sensor)
      return self.recv_hasBinary()
  
    def send_hasBinary(self, sensor):
      self._oprot.writeMessageBegin('hasBinary', TMessageType.CALL, self._seqid)
      args = hasBinary_args()
      args.sensor = sensor
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_hasBinary(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = hasBinary_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "hasBinary failed: unknown result");
  
    def getSensorLabels(self, sensor):
      """
      Parameters:
       - sensor
      """
      self.send_getSensorLabels(sensor)
      return self.recv_getSensorLabels()
  
    def send_getSensorLabels(self, sensor):
      self._oprot.writeMessageBegin('getSensorLabels', TMessageType.CALL, self._seqid)
      args = getSensorLabels_args()
      args.sensor = sensor
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getSensorLabels(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getSensorLabels_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getSensorLabels failed: unknown result");
  
    def delSensor(self, sensor):
      """
      Parameters:
       - sensor
      """
      self.send_delSensor(sensor)
      self.recv_delSensor()
  
    def send_delSensor(self, sensor):
      self._oprot.writeMessageBegin('delSensor', TMessageType.CALL, self._seqid)
      args = delSensor_args()
      args.sensor = sensor
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_delSensor(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = delSensor_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def setSensorLabels(self, sensor, labels):
      """
      Parameters:
       - sensor
       - labels
      """
      self.send_setSensorLabels(sensor, labels)
      self.recv_setSensorLabels()
  
    def send_setSensorLabels(self, sensor, labels):
      self._oprot.writeMessageBegin('setSensorLabels', TMessageType.CALL, self._seqid)
      args = setSensorLabels_args()
      args.sensor = sensor
      args.labels = labels
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_setSensorLabels(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = setSensorLabels_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def setSensorConfiguration(self, sensor, configuration):
      """
      Parameters:
       - sensor
       - configuration
      """
      self.send_setSensorConfiguration(sensor, configuration)
      self.recv_setSensorConfiguration()
  
    def send_setSensorConfiguration(self, sensor, configuration):
      self._oprot.writeMessageBegin('setSensorConfiguration', TMessageType.CALL, self._seqid)
      args = setSensorConfiguration_args()
      args.sensor = sensor
      args.configuration = configuration
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_setSensorConfiguration(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = setSensorConfiguration_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def getSensorConfiguration(self, sensor):
      """
      Parameters:
       - sensor
      """
      self.send_getSensorConfiguration(sensor)
      return self.recv_getSensorConfiguration()
  
    def send_getSensorConfiguration(self, sensor):
      self._oprot.writeMessageBegin('getSensorConfiguration', TMessageType.CALL, self._seqid)
      args = getSensorConfiguration_args()
      args.sensor = sensor
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getSensorConfiguration(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getSensorConfiguration_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getSensorConfiguration failed: unknown result");
  
    def getSensorNames(self, ):
      self.send_getSensorNames()
      return self.recv_getSensorNames()
  
    def send_getSensorNames(self, ):
      self._oprot.writeMessageBegin('getSensorNames', TMessageType.CALL, self._seqid)
      args = getSensorNames_args()
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getSensorNames(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getSensorNames_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getSensorNames failed: unknown result");
  
    def addHost(self, hostname):
      """
      Parameters:
       - hostname
      """
      self.send_addHost(hostname)
      self.recv_addHost()
  
    def send_addHost(self, hostname):
      self._oprot.writeMessageBegin('addHost', TMessageType.CALL, self._seqid)
      args = addHost_args()
      args.hostname = hostname
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_addHost(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = addHost_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def addHostExtension(self, hostname, virtualHostName):
      """
      Parameters:
       - hostname
       - virtualHostName
      """
      self.send_addHostExtension(hostname, virtualHostName)
      self.recv_addHostExtension()
  
    def send_addHostExtension(self, hostname, virtualHostName):
      self._oprot.writeMessageBegin('addHostExtension', TMessageType.CALL, self._seqid)
      args = addHostExtension_args()
      args.hostname = hostname
      args.virtualHostName = virtualHostName
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_addHostExtension(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = addHostExtension_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def getHostExtension(self, hostname):
      """
      Parameters:
       - hostname
      """
      self.send_getHostExtension(hostname)
      return self.recv_getHostExtension()
  
    def send_getHostExtension(self, hostname):
      self._oprot.writeMessageBegin('getHostExtension', TMessageType.CALL, self._seqid)
      args = getHostExtension_args()
      args.hostname = hostname
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getHostExtension(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getHostExtension_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getHostExtension failed: unknown result");
  
    def getAllHosts(self, ):
      self.send_getAllHosts()
      return self.recv_getAllHosts()
  
    def send_getAllHosts(self, ):
      self._oprot.writeMessageBegin('getAllHosts', TMessageType.CALL, self._seqid)
      args = getAllHosts_args()
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getAllHosts(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getAllHosts_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllHosts failed: unknown result");
  
    def delHost(self, hostname):
      """
      Parameters:
       - hostname
      """
      self.send_delHost(hostname)
      self.recv_delHost()
  
    def send_delHost(self, hostname):
      self._oprot.writeMessageBegin('delHost', TMessageType.CALL, self._seqid)
      args = delHost_args()
      args.hostname = hostname
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_delHost(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = delHost_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def setHostLabels(self, hostname, labels):
      """
      Parameters:
       - hostname
       - labels
      """
      self.send_setHostLabels(hostname, labels)
      self.recv_setHostLabels()
  
    def send_setHostLabels(self, hostname, labels):
      self._oprot.writeMessageBegin('setHostLabels', TMessageType.CALL, self._seqid)
      args = setHostLabels_args()
      args.hostname = hostname
      args.labels = labels
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_setHostLabels(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = setHostLabels_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def getLabels(self, hostname):
      """
      Parameters:
       - hostname
      """
      self.send_getLabels(hostname)
      return self.recv_getLabels()
  
    def send_getLabels(self, hostname):
      self._oprot.writeMessageBegin('getLabels', TMessageType.CALL, self._seqid)
      args = getLabels_args()
      args.hostname = hostname
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getLabels(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getLabels_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getLabels failed: unknown result");
  
    def setSensor(self, hostname, sensor, activate):
      """
      Parameters:
       - hostname
       - sensor
       - activate
      """
      self.send_setSensor(hostname, sensor, activate)
      self.recv_setSensor()
  
    def send_setSensor(self, hostname, sensor, activate):
      self._oprot.writeMessageBegin('setSensor', TMessageType.CALL, self._seqid)
      args = setSensor_args()
      args.hostname = hostname
      args.sensor = sensor
      args.activate = activate
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_setSensor(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = setSensor_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      return
  
    def getSensors(self, hostname):
      """
      Parameters:
       - hostname
      """
      self.send_getSensors(hostname)
      return self.recv_getSensors()
  
    def send_getSensors(self, hostname):
      self._oprot.writeMessageBegin('getSensors', TMessageType.CALL, self._seqid)
      args = getSensors_args()
      args.hostname = hostname
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getSensors(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getSensors_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getSensors failed: unknown result");
  
    def getBundledSensorConfiguration(self, sensor, hostname):
      """
      Parameters:
       - sensor
       - hostname
      """
      self.send_getBundledSensorConfiguration(sensor, hostname)
      return self.recv_getBundledSensorConfiguration()
  
    def send_getBundledSensorConfiguration(self, sensor, hostname):
      self._oprot.writeMessageBegin('getBundledSensorConfiguration', TMessageType.CALL, self._seqid)
      args = getBundledSensorConfiguration_args()
      args.sensor = sensor
      args.hostname = hostname
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_getBundledSensorConfiguration(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = getBundledSensorConfiguration_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "getBundledSensorConfiguration failed: unknown result");
  
  
  class Processor(Iface, TProcessor):
    def __init__(self, handler):
      self._handler = handler
      self._processMap = {}
      self._processMap["queryLogs"] = Processor.process_queryLogs
      self._processMap["query"] = Processor.process_query
      self._processMap["fetchSensor"] = Processor.process_fetchSensor
      self._processMap["sensorHash"] = Processor.process_sensorHash
      self._processMap["deploySensor"] = Processor.process_deploySensor
      self._processMap["getAllSensors"] = Processor.process_getAllSensors
      self._processMap["hasBinary"] = Processor.process_hasBinary
      self._processMap["getSensorLabels"] = Processor.process_getSensorLabels
      self._processMap["delSensor"] = Processor.process_delSensor
      self._processMap["setSensorLabels"] = Processor.process_setSensorLabels
      self._processMap["setSensorConfiguration"] = Processor.process_setSensorConfiguration
      self._processMap["getSensorConfiguration"] = Processor.process_getSensorConfiguration
      self._processMap["getSensorNames"] = Processor.process_getSensorNames
      self._processMap["addHost"] = Processor.process_addHost
      self._processMap["addHostExtension"] = Processor.process_addHostExtension
      self._processMap["getHostExtension"] = Processor.process_getHostExtension
      self._processMap["getAllHosts"] = Processor.process_getAllHosts
      self._processMap["delHost"] = Processor.process_delHost
      self._processMap["setHostLabels"] = Processor.process_setHostLabels
      self._processMap["getLabels"] = Processor.process_getLabels
      self._processMap["setSensor"] = Processor.process_setSensor
      self._processMap["getSensors"] = Processor.process_getSensors
      self._processMap["getBundledSensorConfiguration"] = Processor.process_getBundledSensorConfiguration
  
    def process(self, iprot, oprot):
      (name, type, seqid) = iprot.readMessageBegin()
      if name not in self._processMap:
        iprot.skip(TType.STRUCT)
        iprot.readMessageEnd()
        x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
        oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
        x.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()
        return
      else:
        self._processMap[name](self, seqid, iprot, oprot)
      return True
  
    def process_queryLogs(self, seqid, iprot, oprot):
      args = queryLogs_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = queryLogs_result()
      result.success = self._handler.queryLogs(args.query)
      oprot.writeMessageBegin("queryLogs", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_query(self, seqid, iprot, oprot):
      args = query_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = query_result()
      result.success = self._handler.query(args.query)
      oprot.writeMessageBegin("query", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_fetchSensor(self, seqid, iprot, oprot):
      args = fetchSensor_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = fetchSensor_result()
      result.success = self._handler.fetchSensor(args.name)
      oprot.writeMessageBegin("fetchSensor", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_sensorHash(self, seqid, iprot, oprot):
      args = sensorHash_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = sensorHash_result()
      result.success = self._handler.sensorHash(args.name)
      oprot.writeMessageBegin("sensorHash", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_deploySensor(self, seqid, iprot, oprot):
      args = deploySensor_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = deploySensor_result()
      self._handler.deploySensor(args.name, args.file)
      oprot.writeMessageBegin("deploySensor", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getAllSensors(self, seqid, iprot, oprot):
      args = getAllSensors_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getAllSensors_result()
      result.success = self._handler.getAllSensors()
      oprot.writeMessageBegin("getAllSensors", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_hasBinary(self, seqid, iprot, oprot):
      args = hasBinary_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = hasBinary_result()
      result.success = self._handler.hasBinary(args.sensor)
      oprot.writeMessageBegin("hasBinary", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getSensorLabels(self, seqid, iprot, oprot):
      args = getSensorLabels_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getSensorLabels_result()
      result.success = self._handler.getSensorLabels(args.sensor)
      oprot.writeMessageBegin("getSensorLabels", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_delSensor(self, seqid, iprot, oprot):
      args = delSensor_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = delSensor_result()
      self._handler.delSensor(args.sensor)
      oprot.writeMessageBegin("delSensor", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_setSensorLabels(self, seqid, iprot, oprot):
      args = setSensorLabels_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = setSensorLabels_result()
      self._handler.setSensorLabels(args.sensor, args.labels)
      oprot.writeMessageBegin("setSensorLabels", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_setSensorConfiguration(self, seqid, iprot, oprot):
      args = setSensorConfiguration_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = setSensorConfiguration_result()
      self._handler.setSensorConfiguration(args.sensor, args.configuration)
      oprot.writeMessageBegin("setSensorConfiguration", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getSensorConfiguration(self, seqid, iprot, oprot):
      args = getSensorConfiguration_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getSensorConfiguration_result()
      result.success = self._handler.getSensorConfiguration(args.sensor)
      oprot.writeMessageBegin("getSensorConfiguration", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getSensorNames(self, seqid, iprot, oprot):
      args = getSensorNames_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getSensorNames_result()
      result.success = self._handler.getSensorNames()
      oprot.writeMessageBegin("getSensorNames", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_addHost(self, seqid, iprot, oprot):
      args = addHost_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = addHost_result()
      self._handler.addHost(args.hostname)
      oprot.writeMessageBegin("addHost", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_addHostExtension(self, seqid, iprot, oprot):
      args = addHostExtension_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = addHostExtension_result()
      self._handler.addHostExtension(args.hostname, args.virtualHostName)
      oprot.writeMessageBegin("addHostExtension", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getHostExtension(self, seqid, iprot, oprot):
      args = getHostExtension_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getHostExtension_result()
      result.success = self._handler.getHostExtension(args.hostname)
      oprot.writeMessageBegin("getHostExtension", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getAllHosts(self, seqid, iprot, oprot):
      args = getAllHosts_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getAllHosts_result()
      result.success = self._handler.getAllHosts()
      oprot.writeMessageBegin("getAllHosts", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_delHost(self, seqid, iprot, oprot):
      args = delHost_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = delHost_result()
      self._handler.delHost(args.hostname)
      oprot.writeMessageBegin("delHost", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_setHostLabels(self, seqid, iprot, oprot):
      args = setHostLabels_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = setHostLabels_result()
      self._handler.setHostLabels(args.hostname, args.labels)
      oprot.writeMessageBegin("setHostLabels", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getLabels(self, seqid, iprot, oprot):
      args = getLabels_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getLabels_result()
      result.success = self._handler.getLabels(args.hostname)
      oprot.writeMessageBegin("getLabels", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_setSensor(self, seqid, iprot, oprot):
      args = setSensor_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = setSensor_result()
      self._handler.setSensor(args.hostname, args.sensor, args.activate)
      oprot.writeMessageBegin("setSensor", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getSensors(self, seqid, iprot, oprot):
      args = getSensors_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getSensors_result()
      result.success = self._handler.getSensors(args.hostname)
      oprot.writeMessageBegin("getSensors", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_getBundledSensorConfiguration(self, seqid, iprot, oprot):
      args = getBundledSensorConfiguration_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = getBundledSensorConfiguration_result()
      result.success = self._handler.getBundledSensorConfiguration(args.sensor, args.hostname)
      oprot.writeMessageBegin("getBundledSensorConfiguration", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
  
  # HELPER FUNCTIONS AND STRUCTURES
  
  class queryLogs_args:
    """
    Attributes:
     - query
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'query', (LogsQuery, LogsQuery.thrift_spec), None, ), # 1
    )
  
    def __init__(self, query=None,):
      self.query = query
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.query = LogsQuery()
            self.query.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('queryLogs_args')
      if self.query is not None:
        oprot.writeFieldBegin('query', TType.STRUCT, 1)
        self.query.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class queryLogs_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.LIST, 'success', (TType.STRUCT,(LogMessage, LogMessage.thrift_spec)), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.LIST:
            self.success = []
            (_etype59, _size56) = iprot.readListBegin()
            for _i60 in xrange(_size56):
              _elem61 = LogMessage()
              _elem61.read(iprot)
              self.success.append(_elem61)
            iprot.readListEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('queryLogs_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.LIST, 0)
        oprot.writeListBegin(TType.STRUCT, len(self.success))
        for iter62 in self.success:
          iter62.write(oprot)
        oprot.writeListEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class query_args:
    """
    Attributes:
     - query
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'query', (TimeSeriesQuery, TimeSeriesQuery.thrift_spec), None, ), # 1
    )
  
    def __init__(self, query=None,):
      self.query = query
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.query = TimeSeriesQuery()
            self.query.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('query_args')
      if self.query is not None:
        oprot.writeFieldBegin('query', TType.STRUCT, 1)
        self.query.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class query_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.LIST, 'success', (TType.STRUCT,(TransferableTimeSeriesPoint, TransferableTimeSeriesPoint.thrift_spec)), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.LIST:
            self.success = []
            (_etype66, _size63) = iprot.readListBegin()
            for _i67 in xrange(_size63):
              _elem68 = TransferableTimeSeriesPoint()
              _elem68.read(iprot)
              self.success.append(_elem68)
            iprot.readListEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('query_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.LIST, 0)
        oprot.writeListBegin(TType.STRUCT, len(self.success))
        for iter69 in self.success:
          iter69.write(oprot)
        oprot.writeListEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class fetchSensor_args:
    """
    Attributes:
     - name
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'name', None, None, ), # 1
    )
  
    def __init__(self, name=None,):
      self.name = name
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.name = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('fetchSensor_args')
      if self.name is not None:
        oprot.writeFieldBegin('name', TType.STRING, 1)
        oprot.writeString(self.name)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class fetchSensor_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRING, 'success', None, None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRING:
            self.success = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('fetchSensor_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRING, 0)
        oprot.writeString(self.success)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class sensorHash_args:
    """
    Attributes:
     - name
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'name', None, None, ), # 1
    )
  
    def __init__(self, name=None,):
      self.name = name
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.name = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('sensorHash_args')
      if self.name is not None:
        oprot.writeFieldBegin('name', TType.STRING, 1)
        oprot.writeString(self.name)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class sensorHash_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRING, 'success', None, None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRING:
            self.success = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('sensorHash_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRING, 0)
        oprot.writeString(self.success)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class deploySensor_args:
    """
    Attributes:
     - name
     - file
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'name', None, None, ), # 1
      (2, TType.STRING, 'file', None, None, ), # 2
    )
  
    def __init__(self, name=None, file=None,):
      self.name = name
      self.file = file
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.name = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 2:
          if ftype == TType.STRING:
            self.file = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('deploySensor_args')
      if self.name is not None:
        oprot.writeFieldBegin('name', TType.STRING, 1)
        oprot.writeString(self.name)
        oprot.writeFieldEnd()
      if self.file is not None:
        oprot.writeFieldBegin('file', TType.STRING, 2)
        oprot.writeString(self.file)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class deploySensor_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('deploySensor_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getAllSensors_args:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getAllSensors_args')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getAllSensors_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.SET:
            self.success = set()
            (_etype73, _size70) = iprot.readSetBegin()
            for _i74 in xrange(_size70):
              _elem75 = iprot.readString();
              self.success.add(_elem75)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getAllSensors_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.SET, 0)
        oprot.writeSetBegin(TType.STRING, len(self.success))
        for iter76 in self.success:
          oprot.writeString(iter76)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class hasBinary_args:
    """
    Attributes:
     - sensor
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
    )
  
    def __init__(self, sensor=None,):
      self.sensor = sensor
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('hasBinary_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class hasBinary_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.BOOL, 'success', None, None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.BOOL:
            self.success = iprot.readBool();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('hasBinary_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.BOOL, 0)
        oprot.writeBool(self.success)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensorLabels_args:
    """
    Attributes:
     - sensor
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
    )
  
    def __init__(self, sensor=None,):
      self.sensor = sensor
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensorLabels_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensorLabels_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.SET:
            self.success = set()
            (_etype80, _size77) = iprot.readSetBegin()
            for _i81 in xrange(_size77):
              _elem82 = iprot.readString();
              self.success.add(_elem82)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensorLabels_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.SET, 0)
        oprot.writeSetBegin(TType.STRING, len(self.success))
        for iter83 in self.success:
          oprot.writeString(iter83)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class delSensor_args:
    """
    Attributes:
     - sensor
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
    )
  
    def __init__(self, sensor=None,):
      self.sensor = sensor
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('delSensor_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class delSensor_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('delSensor_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setSensorLabels_args:
    """
    Attributes:
     - sensor
     - labels
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
      None, # 2
      (3, TType.SET, 'labels', (TType.STRING,None), None, ), # 3
    )
  
    def __init__(self, sensor=None, labels=None,):
      self.sensor = sensor
      self.labels = labels
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 3:
          if ftype == TType.SET:
            self.labels = set()
            (_etype87, _size84) = iprot.readSetBegin()
            for _i88 in xrange(_size84):
              _elem89 = iprot.readString();
              self.labels.add(_elem89)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setSensorLabels_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      if self.labels is not None:
        oprot.writeFieldBegin('labels', TType.SET, 3)
        oprot.writeSetBegin(TType.STRING, len(self.labels))
        for iter90 in self.labels:
          oprot.writeString(iter90)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setSensorLabels_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setSensorLabels_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setSensorConfiguration_args:
    """
    Attributes:
     - sensor
     - configuration
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
      (2, TType.STRUCT, 'configuration', (SensorConfiguration, SensorConfiguration.thrift_spec), None, ), # 2
    )
  
    def __init__(self, sensor=None, configuration=None,):
      self.sensor = sensor
      self.configuration = configuration
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 2:
          if ftype == TType.STRUCT:
            self.configuration = SensorConfiguration()
            self.configuration.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setSensorConfiguration_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      if self.configuration is not None:
        oprot.writeFieldBegin('configuration', TType.STRUCT, 2)
        self.configuration.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setSensorConfiguration_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setSensorConfiguration_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensorConfiguration_args:
    """
    Attributes:
     - sensor
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
    )
  
    def __init__(self, sensor=None,):
      self.sensor = sensor
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensorConfiguration_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensorConfiguration_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (SensorConfiguration, SensorConfiguration.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = SensorConfiguration()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensorConfiguration_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensorNames_args:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensorNames_args')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensorNames_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.SET:
            self.success = set()
            (_etype94, _size91) = iprot.readSetBegin()
            for _i95 in xrange(_size91):
              _elem96 = iprot.readString();
              self.success.add(_elem96)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensorNames_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.SET, 0)
        oprot.writeSetBegin(TType.STRING, len(self.success))
        for iter97 in self.success:
          oprot.writeString(iter97)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class addHost_args:
    """
    Attributes:
     - hostname
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
    )
  
    def __init__(self, hostname=None,):
      self.hostname = hostname
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('addHost_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class addHost_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('addHost_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class addHostExtension_args:
    """
    Attributes:
     - hostname
     - virtualHostName
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
      (2, TType.STRING, 'virtualHostName', None, None, ), # 2
    )
  
    def __init__(self, hostname=None, virtualHostName=None,):
      self.hostname = hostname
      self.virtualHostName = virtualHostName
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 2:
          if ftype == TType.STRING:
            self.virtualHostName = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('addHostExtension_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      if self.virtualHostName is not None:
        oprot.writeFieldBegin('virtualHostName', TType.STRING, 2)
        oprot.writeString(self.virtualHostName)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class addHostExtension_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('addHostExtension_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getHostExtension_args:
    """
    Attributes:
     - hostname
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
    )
  
    def __init__(self, hostname=None,):
      self.hostname = hostname
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getHostExtension_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getHostExtension_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRING, 'success', None, None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRING:
            self.success = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getHostExtension_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRING, 0)
        oprot.writeString(self.success)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getAllHosts_args:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getAllHosts_args')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getAllHosts_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.SET:
            self.success = set()
            (_etype101, _size98) = iprot.readSetBegin()
            for _i102 in xrange(_size98):
              _elem103 = iprot.readString();
              self.success.add(_elem103)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getAllHosts_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.SET, 0)
        oprot.writeSetBegin(TType.STRING, len(self.success))
        for iter104 in self.success:
          oprot.writeString(iter104)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class delHost_args:
    """
    Attributes:
     - hostname
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
    )
  
    def __init__(self, hostname=None,):
      self.hostname = hostname
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('delHost_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class delHost_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('delHost_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setHostLabels_args:
    """
    Attributes:
     - hostname
     - labels
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
      (2, TType.SET, 'labels', (TType.STRING,None), None, ), # 2
    )
  
    def __init__(self, hostname=None, labels=None,):
      self.hostname = hostname
      self.labels = labels
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 2:
          if ftype == TType.SET:
            self.labels = set()
            (_etype108, _size105) = iprot.readSetBegin()
            for _i109 in xrange(_size105):
              _elem110 = iprot.readString();
              self.labels.add(_elem110)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setHostLabels_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      if self.labels is not None:
        oprot.writeFieldBegin('labels', TType.SET, 2)
        oprot.writeSetBegin(TType.STRING, len(self.labels))
        for iter111 in self.labels:
          oprot.writeString(iter111)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setHostLabels_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setHostLabels_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getLabels_args:
    """
    Attributes:
     - hostname
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
    )
  
    def __init__(self, hostname=None,):
      self.hostname = hostname
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getLabels_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getLabels_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.SET:
            self.success = set()
            (_etype115, _size112) = iprot.readSetBegin()
            for _i116 in xrange(_size112):
              _elem117 = iprot.readString();
              self.success.add(_elem117)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getLabels_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.SET, 0)
        oprot.writeSetBegin(TType.STRING, len(self.success))
        for iter118 in self.success:
          oprot.writeString(iter118)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setSensor_args:
    """
    Attributes:
     - hostname
     - sensor
     - activate
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
      (2, TType.STRING, 'sensor', None, None, ), # 2
      (3, TType.BOOL, 'activate', None, None, ), # 3
    )
  
    def __init__(self, hostname=None, sensor=None, activate=None,):
      self.hostname = hostname
      self.sensor = sensor
      self.activate = activate
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 2:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 3:
          if ftype == TType.BOOL:
            self.activate = iprot.readBool();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setSensor_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 2)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      if self.activate is not None:
        oprot.writeFieldBegin('activate', TType.BOOL, 3)
        oprot.writeBool(self.activate)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class setSensor_result:
  
    thrift_spec = (
    )
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('setSensor_result')
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensors_args:
    """
    Attributes:
     - hostname
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'hostname', None, None, ), # 1
    )
  
    def __init__(self, hostname=None,):
      self.hostname = hostname
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensors_args')
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 1)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getSensors_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.SET, 'success', (TType.STRING,None), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.SET:
            self.success = set()
            (_etype122, _size119) = iprot.readSetBegin()
            for _i123 in xrange(_size119):
              _elem124 = iprot.readString();
              self.success.add(_elem124)
            iprot.readSetEnd()
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getSensors_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.SET, 0)
        oprot.writeSetBegin(TType.STRING, len(self.success))
        for iter125 in self.success:
          oprot.writeString(iter125)
        oprot.writeSetEnd()
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getBundledSensorConfiguration_args:
    """
    Attributes:
     - sensor
     - hostname
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRING, 'sensor', None, None, ), # 1
      (2, TType.STRING, 'hostname', None, None, ), # 2
    )
  
    def __init__(self, sensor=None, hostname=None,):
      self.sensor = sensor
      self.hostname = hostname
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRING:
            self.sensor = iprot.readString();
          else:
            iprot.skip(ftype)
        elif fid == 2:
          if ftype == TType.STRING:
            self.hostname = iprot.readString();
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getBundledSensorConfiguration_args')
      if self.sensor is not None:
        oprot.writeFieldBegin('sensor', TType.STRING, 1)
        oprot.writeString(self.sensor)
        oprot.writeFieldEnd()
      if self.hostname is not None:
        oprot.writeFieldBegin('hostname', TType.STRING, 2)
        oprot.writeString(self.hostname)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class getBundledSensorConfiguration_result:
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (BundledSensorConfiguration, BundledSensorConfiguration.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = BundledSensorConfiguration()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('getBundledSensorConfiguration_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  