def _get_detected_chips():  # pragma: no cover
    sensors.cleanup()
    sensors.init()

    chips_detected = list(sensors.iter_detected_chips())

    return chips_detected

    def check(self, instance):
        ## Capture CPU temperature stats
        dimensions = self._set_dimensions(None, instance)

        sensors.init()
        stats ={}
        try:
          for chip in sensors.iter_detected_chips():
            # Only temps from ISA adpters that are deteced by lm_sensors
            if (chip.adapter_name == "ISA adapter"):
              for feature in chip:
                if "Core" in feature.label:
                  name = feature.label.replace(" ", "_")
                  name = name.lower()
                  stats["cpu."+str(chip)+"."+str(name)+"_temperature"] = feature.get_value()
                elif "Physical id" in feature.label:
                  name = feature.label.replace(" ", "_")
                  name = name.lower()
                  stats["cpu."+str(chip)+".max_temperature"] = feature.get_value()
        finally:
          sensors.cleanup()
        for key, value in stats.iteritems():
          # Writes data to monasca that will go to InfluxDB
          self.gauge(key, value, dimensions)
        log.debug('Collected {0} cpu temp metrics'.format(len(stats)))                                                                                        1,1           Top

    def get_sensors(self):
        """
        collects the current temperature of CPU
        and each core
        """

        sensors.init()
        added = []
        cpu_temp_c = []
        try:
            for chip in sensors.iter_detected_chips():
                for feature in chip:
                    if feature.name.startswith('temp'):
                        if ((feature.label.startswith('Physical') or
                                feature.label.startswith('CPU')) and
                                feature.label not in added):
                            self._status.add_cpu_temp(feature.get_value())
                        elif (feature.label.startswith('Core')
                                and feature.label not in added):
                            cpu_temp_c.append(feature.get_value())
                        added.append(feature.label)
        except sensors.SensorsError:
            pass
        if cpu_temp_c:
            try:
                self._status.add_cpu_temp_core(cpu_temp_c)
            except IndexError:
                pass
        sensors.cleanup()

def getY():
    sensors.init() # Inicializamos sensores
    temperaturas = [] # Guarda todas las tempereturas
                      #detectadas
    suma_total = 0 # Variable de apoyo
    try:
        # Recorremos todos los sensores detectados
        for chip in sensors.iter_detected_chips():
            a = chip
            b = chip.adapter_name
            if b == "PCI adapter":
                print "Procesador >", a,
                for core in chip:
                    print "",core.get_value(), "C"
                    # Agregamos a la lista
                    temperaturas.append(core.get_value()) 

        total_tempe = len(temperaturas)        
        suma_total = sum(suma for suma in temperaturas)

        prom = int(suma_total) / total_tempe
    finally:
        sensors.cleanup() # Cerramos los sensores
    print "prom =>", prom
    print "--------------------------------------"
    if SERIAL: ser.write(str(prom)) # Enviamos el prom al arduino
    return prom

def process_temp():
    print("-" * 50)
    sensors.init()
    critical = False
    try:
        for chip in sensors.ChipIterator():
            for feature in sensors.FeatureIterator(chip):
                subs = list(sensors.SubFeatureIterator(chip, feature))
                critical = None
                current = None
                for sub in subs:
                    value = sensors.get_value(chip, sub.number)
                    if sub.name.endswith(b"input"):
                        current = value
                    if sub.name.endswith(b"crit"):
                        critical_value = value
                name = sensors.get_label(chip, feature)
                print("Current temp for {}: {} / {}".format(name, current,
                                                            critical_value))
                if current >= critical_value:
                    critical = True
        if critical:
            play_critical()
    finally:
        sensors.cleanup()

 def get_lmsensor(self):
     """
     """
     if self._lmsensor_next_run < datetime.now():
         locked = self._lock.acquire(False)
         if locked == True:
             try:
                 _lmsensor = {}
                 pysensors.init(config_filename=self.values["config_filename"].data)
                 try:
                     for chip in pysensors.iter_detected_chips():
                         _lmsensor['%s'%chip] = {}
                         for feature in chip:
                             _lmsensor['%s'%chip][feature.label] = feature.get_value()
                 except Exception:
                     logger.exception("[%s] - Exception in get_lmsensor", self.__class__.__name__)
                 finally:
                     pysensors.cleanup()
                 for val_id in ['temperature', 'voltage']:
                     for config in self.values[val_id].get_index_configs():
                         for chip in _lmsensor:
                             if config in _lmsensor[chip] :
                                 self.values[val_id].set_data_index(config=config, data=_lmsensor[chip][config])
                 self._lmsensor_last = True
             except Exception:
                 logger.exception("[%s] - Exception in get_lmsensor", self.__class__.__name__)
                 self._lmsensor_last = False
             finally:
                 self._lock.release()
                 min_poll=99999
                 for val_id in ['temperature_poll', 'voltage_poll']:
                     if self.values[val_id].data > 0:
                         min_poll=min(min_poll, self.values[val_id].data)
                 self._lmsensor_next_run = datetime.now() + timedelta(seconds=min_poll)

def metric_init(params):
    global descriptors
    
    sensors.init()
    corelist = []
    
    try:
        for chip in sensors.iter_detected_chips():
            if chip.prefix == CORETEMP:
                for feature in chip:
                    if feature.label.startswith('Core'):
                        corelist.append("%s Temperature" % feature.label)
    except:
        raise
    finally:
        sensors.cleanup()

    for core in corelist:
        print 'name: %s' % core
        descriptors.append({'name': core,
                                'call_back': temp_handler,
                                'time_max': 90,
                                'value_type': 'float',
                                'units': 'Celsius',
                                'slope': 'both',
                                'format': '%.2f',
                                'description': 'Temperature of %s' % core,
                                'groups': 'Node Health'})
    return descriptors

def serve(port):
    sensors.init()
    server = Server("localhost", port)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        server.server_close()
    finally:
        sensors.cleanup()

def getDictTemp():
  result = dict()
  sensors.init()
  try:
      for chip in sensors.iter_detected_chips():
          for feature in chip:
              result[str(feature.label)] = str(feature.get_value())
  finally:
      sensors.cleanup()
  return result

def main():
    try:
        sensors.init()

        log_thread = threading.Thread(target=lambda: run_log(60.0))
        log_thread.daemon = True
        log_thread.start()

        http_viewer.run()
    finally:
        sensors.cleanup()

    def collect(self):
        if sensors is None:
            self.log.error('Unable to import module sensors')
            return {}

        sensors.init()
        try:
            for chip in sensors.iter_detected_chips():
                for feature in chip:
                    self.publish(".".join([str(chip), feature.label]), feature.get_value())
        finally:
            sensors.cleanup()

def temp_handler(name): 
    sensors.init()
    temp = 0.0
    try:
        for chip in sensors.iter_detected_chips():
            if chip.prefix == CORETEMP:
                for feature in chip:
                    if '%s Temperature' % feature.label == name:
                        temp = feature.get_value()
    finally:
        sensors.cleanup()
    return temp

def get_temp():
    sensors.init()
    temp = 0
    try:
        for chip in sensors.iter_detected_chips():
            for feature in chip:
                sensor_temp = feature.get_value()
                if sensor_temp > temp:
                    temp = sensor_temp
    finally:
        sensors.cleanup()

    return temp

 def run(self):
     """
     Main program loop. Keep checking the temperature and set fan speed.
     """
     while True:
         try:
             self.check_temperature()
             time.sleep(self.poll_time)
         except Exception, details:
             self.log.error("Main loop ended with exception: %s", details)
             self.log.error("Daemon is shutting down...")
             sensors.cleanup()
             sys.exit(1)

def getTemp(name):
  result = dict()
  sensors.init()
  try:
    for chip in sensors.iter_detected_chips():
        for feature in chip:
          try:
              if feature.label == name:
                return feature.get_value()
          except:
            pass
  finally:
      sensors.cleanup()

def main():
    monitor = Monitor()

    updateThread = Thread(target=monitor.update)
    sendThread = Thread(target=monitor.send)

    updateThread.daemon = True
    sendThread.daemon = True

    updateThread.start()
    sendThread.start()

    while (1):
        sleep(1000)

    sensors.cleanup()

def coretemp_handler(name):
    
    sensors.init()
    value = 0
    try:
        for chip in sensors.iter_detected_chips():
            if chip.prefix.startswith('coretemp'):
                for feature in chip:
                    if feature.label == name:
                        value = feature.get_value()
                        break
    except:
        print "WTF?!?"
    finally:
        sensors.cleanup()
    return value

def main():
    sensors.init()
    try:
        for chip in sensors.iter_detected_chips():
            print(chip)
            print('Adapter:', chip.adapter_name)
            for feature in chip:
                print('%s (%r): %.1f' % (
                    feature.name, feature.label, feature.get_value()
                ))
                for subfeature in feature:
                    print('  %s: %.1f' % (
                        subfeature.name, subfeature.get_value()
                    ))
            print()
    finally:
        sensors.cleanup()

    def collect(self):
        if sensors is None:
            self.log.error('Unable to import module sensors')
            return {}

        sensors.init()
        try:
            for chip in sensors.iter_detected_chips():
                for feature in chip:
                    label = feature.label.replace(' ', '-')
                    value = None
                    try:
                        value = feature.get_value()
                    except Exception:
                        if str_to_bool(self.config['send_zero']):
                            value = 0

                    if value is not None:
                        self.publish(".".join([str(chip), label]), value)
        finally:
            sensors.cleanup()

def metric_init(params):
    global descriptors
    
    metric_group = params.get('metric_group', 'coretemp')
    sensors.init()

    for chip in sensors.iter_detected_chips():
        for feature in chip:
            if chip.prefix.startswith('coretemp'):
                descriptors.append({
                    'name': feature.label,
                    'call_back' : coretemp_handler,
                    'time_max' : 60,
                    'units': 'C',
                    'format' : '%.2f',
                    'slope' : 'both',
                    'description' : 'CPU Core Temperature',
                    'groups' : metric_group,
                }) 
    sensors.cleanup()

    return descriptors