docs: def update(self):
          """Update disk I/O stats using the input method."""
          # Init new stats
          stats = self.get_init_value()
  
          if self.input_method == 'local':
              # Update stats using the standard system lib
              # Grab the stat using the psutil disk_io_counters method
              # read_count: number of reads
              # write_count: number of writes
              # read_bytes: number of bytes read
              # write_bytes: number of bytes written
              # read_time: time spent reading from disk (in milliseconds)
              # write_time: time spent writing to disk (in milliseconds)
              try:
                  diskiocounters = psutil.disk_io_counters(perdisk=True)
              except Exception:
                  return stats
  
              # Previous disk IO stats are stored in the diskio_old variable
              if not hasattr(self, 'diskio_old'):
                  # First call, we init the diskio_old var
                  try:
                      self.diskio_old = diskiocounters
                  except (IOError, UnboundLocalError):
                      pass
              else:
                  # By storing time data we enable Rx/s and Tx/s calculations in the
                  # XML/RPC API, which would otherwise be overly difficult work
                  # for users of the API
                  time_since_update = getTimeSinceLastUpdate('disk')
  
                  diskio_new = diskiocounters
                  for disk in diskio_new:
                      # By default, RamFS is not displayed (issue #714)
                      if self.args is not None and not self.args.diskio_show_ramfs and disk.startswith('ram'):
                          continue
  
                      # Do not take hide disk into account
                      if self.is_hide(disk):
                          continue
  
                      # Compute count and bit rate
                      try:
                          read_count = (diskio_new[disk].read_count -
                                        self.diskio_old[disk].read_count)
                          write_count = (diskio_new[disk].write_count -
                                         self.diskio_old[disk].write_count)
                          read_bytes = (diskio_new[disk].read_bytes -
                                        self.diskio_old[disk].read_bytes)
                          write_bytes = (diskio_new[disk].write_bytes -
                                         self.diskio_old[disk].write_bytes)
                          diskstat = {
                              'time_since_update': time_since_update,
                              'disk_name': n(disk),
                              'read_count': read_count,
                              'write_count': write_count,
                              'read_bytes': read_bytes,
                              'write_bytes': write_bytes}
                          # Add alias if exist (define in the configuration file)
                          if self.has_alias(disk) is not None:
                              diskstat['alias'] = self.has_alias(disk)
                      except KeyError:
                          continue
                      else:
                          diskstat['key'] = self.get_key()
                          stats.append(diskstat)
  
                  # Save stats to compute next bitrate
                  self.diskio_old = diskio_new
          elif self.input_method == 'snmp':
              # Update stats using SNMP
              # No standard way for the moment...
              pass
  
          # Update the stats
          self.stats = stats
  
          return self.stats