Update the parking brake sensor.
556862
def update(self):
        """"""
        self._controller.update(self._id, wake_if_asleep=False)
        data = self._controller.get_drive_params(self._id)
        if data:
            if not data['shift_state'] or data['shift_state'] == 'P':
                self.__state = True
            else:
                self.__state = False
713942
def add_update_callback(self, callback, sensor):
        """"""
        self._updateCallbacks.append([callback, sensor])
        _LOGGING.debug('Added update callback to %s on %s', callback, sensor)
963642
def update(self):
        """"""
        self._attrs = self._session.refresh_attributes(self.name)
        self._attrs = assert_is_dict(self._attrs)

        # force base_state to update properties
        if self.base_station:
            self.base_station.update()
892496
def update_connected(self, status):
        """"""
        self._client['connected'] = status
        _LOGGER.info('updated connected status to %s on %s', status, self.friendly_name)
        self.callback()
614416
def notify_update(self):
    """"""
    with self._lock:
      for event in self._update_events:
        event.set()
      self._update_events.clear()
389867
def update(self):
        """"""
        vehicle = self.api.vehicles(vid=self.vid)['vehicle']
        newbus = self.fromapi(self.api, vehicle)
        self.__dict__ = newbus.__dict__
        del newbus
1223255
def _update_notification(self, message=None):
        """"""
        if message is None:
            message = ''
        message_label = self._parts['notification label']
        message_label.config(text=message)
        self._base.update()
335394
def update(self):
        
        with self._lock:
            if self._state == Bundle.ACTIVE:
                self.stop()
                self.start()
416225
def __update_service_status(self, statuscode):
        """"""
        if self.__service_status != statuscode:
            self.__service_status = statuscode
            self.__send_service_status_to_frontend()
1011556
def _mems_updated_cb(self):
        """"""
        logger.info('Memories finished updating')
        self.param.refresh_toc(self._param_toc_updated_cb, self._toc_cache)
148975
function update(latest) {
    if (latest === null || latest === undefined) {
      isGap = true
      return
    }

    if (offset >= latest) {
      return
    }

    if (isGap) {
      gaps.push({start: offset, end: latest})
      isGap = false
    }

    offset = latest
  }
456574
def set_status(self, enabled):
        """"""
        self.__manual_update_time = time.time()
        if enabled:
            data = self._controller.command(self._id,
                                            'auto_conditioning_start',
                                            wake_if_asleep=True)
            if data['response']['result']:
                self.__is_auto_conditioning_on = True
                self.__is_climate_on = True
        else:
            data = self._controller.command(self._id,
                                            'auto_conditioning_stop',
                                            wake_if_asleep=True)
            if data['response']['result']:
                self.__is_auto_conditioning_on = False
                self.__is_climate_on = False
        self.update()
858916
def set_value(self, value, status=Sensor.NOMINAL, timestamp=None):
        """"""
        if timestamp is None:
            timestamp = self._manager.time()
        self.set(timestamp, status, value)
597787
def _cb_inform_sensor_status(self, msg):
        """"""
        timestamp = msg.arguments[0]
        num_sensors = int(msg.arguments[1])
        assert len(msg.arguments) == 2 + num_sensors * 3
        for n in xrange(num_sensors):
            name = msg.arguments[2 + n * 3]
            status = msg.arguments[3 + n * 3]
            value = msg.arguments[4 + n * 3]
            self.update_sensor(name, timestamp, status, value)
1305871
def _timer_update(self):
        """"""
        self._timer_counter += 1
        dot = self._timer_dots.pop(0)
        self._timer_dots = self._timer_dots + [dot]
        self._rows = [[_(u'Resolving dependencies') + dot, u'', u'', u'']]
        index = self.createIndex(0, 0)
        self.dataChanged.emit(index, index)

        if self._timer_counter > 150:
            self._timer.stop()
            self._timer_counter = 0
138603
def make_update(self, nids, fw_type, fw_ver, fw_bin=None):
        """"""
        try:
            fw_type, fw_ver = int(fw_type), int(fw_ver)
        except ValueError:
            _LOGGER.error(
                'Firmware type %s or version %s not valid, '
                'please enter integers', fw_type, fw_ver)
            return
        if fw_bin is not None:
            fware = prepare_fw(fw_bin)
            self.firmware[fw_type, fw_ver] = fware
        if (fw_type, fw_ver) not in self.firmware:
            _LOGGER.error(
                'No firmware of type %s and version %s found, '
                'please enter path to firmware in call', fw_type, fw_ver)
            return
        if not isinstance(nids, list):
            nids = [nids]
        for node_id in nids:
            if node_id not in self._sensors:
                continue
            for store in self.unstarted, self.started:
                store.pop(node_id, None)
            self.requested[node_id] = fw_type, fw_ver
            self._sensors[node_id].reboot = True
947439
def update(self, json_state):
        
        if self._type in CONST.BINARY_SENSOR_TYPES:
            self._json_state['status'] = json_state['status']
        else:
            self._json_state.update(
                {k: json_state[k] for k in json_state if self._json_state.get(k)})