Update the pyotgw object with the information from the PS
        command and return the updated status dict.

        This method is a coroutine
485791
async def get_status(self):
        
        cmd = OTGW_CMD_SUMMARY
        ret = await self._wait_for_cmd(cmd, 1)
        # Return to 'reporting' mode
        asyncio.ensure_future(self._wait_for_cmd(cmd, 0), loop=self.loop)
        if ret is None:
            return
        fields = ret[1].split(',')
        device_status = fields[0].split('/')
        master_status = device_status[0]
        slave_status = device_status[1]
        remote_params = fields[2].split('/')
        capmodlimits = fields[4].split('/')
        dhw_setp_bounds = fields[13].split('/')
        ch_setp_bounds = fields[14].split('/')
        status = {
            DATA_MASTER_CH_ENABLED: int(master_status[7]),
            DATA_MASTER_DHW_ENABLED: int(master_status[6]),
            DATA_MASTER_COOLING_ENABLED: int(master_status[5]),
            DATA_MASTER_OTC_ENABLED: int(master_status[4]),
            DATA_MASTER_CH2_ENABLED: int(master_status[3]),
            DATA_SLAVE_FAULT_IND: int(slave_status[7]),
            DATA_SLAVE_CH_ACTIVE: int(slave_status[6]),
            DATA_SLAVE_DHW_ACTIVE: int(slave_status[5]),
            DATA_SLAVE_FLAME_ON: int(slave_status[4]),
            DATA_SLAVE_COOLING_ACTIVE: int(slave_status[3]),
            DATA_SLAVE_CH2_ACTIVE: int(slave_status[2]),
            DATA_SLAVE_DIAG_IND: int(slave_status[1]),
            DATA_CONTROL_SETPOINT: float(fields[1]),
            DATA_REMOTE_TRANSFER_DHW: int(remote_params[0][7]),
            DATA_REMOTE_TRANSFER_MAX_CH: int(remote_params[0][6]),
            DATA_REMOTE_RW_DHW: int(remote_params[1][7]),
            DATA_REMOTE_RW_MAX_CH: int(remote_params[1][6]),
            DATA_SLAVE_MAX_RELATIVE_MOD: float(fields[3]),
            DATA_SLAVE_MAX_CAPACITY: int(capmodlimits[0]),
            DATA_SLAVE_MIN_MOD_LEVEL: int(capmodlimits[1]),
            DATA_ROOM_SETPOINT: float(fields[5]),
            DATA_REL_MOD_LEVEL: float(fields[6]),
            DATA_CH_WATER_PRESS: float(fields[7]),
            DATA_ROOM_TEMP: float(fields[8]),
            DATA_CH_WATER_TEMP: float(fields[9]),
            DATA_DHW_TEMP: float(fields[10]),
            DATA_OUTSIDE_TEMP: float(fields[11]),
            DATA_RETURN_WATER_TEMP: float(fields[12]),
            DATA_SLAVE_DHW_MAX_SETP: int(dhw_setp_bounds[0]),
            DATA_SLAVE_DHW_MIN_SETP: int(dhw_setp_bounds[1]),
            DATA_SLAVE_CH_MAX_SETP: int(ch_setp_bounds[0]),
            DATA_SLAVE_CH_MIN_SETP: int(ch_setp_bounds[1]),
            DATA_DHW_SETPOINT: float(fields[15]),
            DATA_MAX_CH_SETPOINT: float(fields[16]),
            DATA_TOTAL_BURNER_STARTS: int(fields[17]),
            DATA_CH_PUMP_STARTS: int(fields[18]),
            DATA_DHW_PUMP_STARTS: int(fields[19]),
            DATA_DHW_BURNER_STARTS: int(fields[20]),
            DATA_TOTAL_BURNER_HOURS: int(fields[21]),
            DATA_CH_PUMP_HOURS: int(fields[22]),
            DATA_DHW_PUMP_HOURS: int(fields[23]),
            DATA_DHW_BURNER_HOURS: int(fields[24])
        }
        self._update_status(status)
        return dict(self._protocol.status)
641642
def do_gui_update(self):
        
        with self.update_lock:
            changed_widget_dict = {}
            self.root.repr(changed_widget_dict)
            for widget in changed_widget_dict.keys():
                html = changed_widget_dict[widget]
                __id = str(widget.identifier)
                self._send_spontaneous_websocket_message(_MSG_UPDATE + __id + ',' + to_websocket(html))
        self._need_update_flag = False
748494
def workflow_update(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/update' % object_id, input_params, always_retry=always_retry, **kwargs)
392258
def update(self, **kwargs):
        

        old_json = self.__json__()

        for prop in kwargs:
            setattr(self, prop, kwargs[prop])

        # We send notif only if object has changed
        if old_json != self.__json__():
            self.controller.notification.emit("project.updated", self.__json__())
            self.dump()
884674
def update():
    # type: () -> None
    
    branch = git.current_branch(refresh=True)
    base_branch = common.get_base_branch()

    common.assert_branch_type('task')
    common.git_checkout(base_branch)
    common.git_pull(base_branch)
    common.git_checkout(branch.name)
    common.git_merge(branch.name, base_branch)
723788
def cli(ctx, id_number, new_value):
    
    return ctx.gi.status.update_status(id_number, new_value)
454930
async def set_setback_temp(self, sb_temp, timeout=OTGW_DEFAULT_TIMEOUT):
        
        cmd = OTGW_CMD_SETBACK
        status = {}
        ret = await self._wait_for_cmd(cmd, sb_temp, timeout)
        if ret is None:
            return
        ret = float(ret)
        status[OTGW_SB_TEMP] = ret
        self._update_status(status)
        return ret
524067
def update_soa_serial(args):
    
    password = get_password(args)
    token = connect.get_token(args.username, password, args.server)
    soa_content = dict(domain=args.domain)
    if args.__dict__.get('mname'):
        soa_content['mname'] = args.mname
    if args.__dict__.get('rname'):
        soa_content['rname'] = args.rname
    if args.__dict__.get('refresh'):
        soa_content['refresh'] = args.refresh
    if args.__dict__.get('retry'):
        soa_content['retry'] = args.retry
    if args.__dict__.get('expire'):
        soa_content['expire'] = args.expire
    if args.__dict__.get('minimum'):
        soa_content['minimum'] = args.minimum
    processing.update_soa_serial(args.server, token, soa_content)
779808
def update(self, **kwargs):
        
        tmos_version = self._meta_data['bigip'].tmos_version
        if LooseVersion(tmos_version) > LooseVersion('12.0.0'):
            msg = "Update() is unsupported for User on version %s. " \
                  "Utilize Modify() method instead" % tmos_version
            raise UnsupportedOperation(msg)
        else:
            self._update(**kwargs)
702933
def update(self, command):
        
        command = wrap(command)
        command_clear = listwrap(command["clear"])
        command_set = command.set.items()
        command_where = jx.get(command.where)

        for c in self.data:
            if command_where(c):
                for k in command_clear:
                    c[k] = None
                for k, v in command_set:
                    c[k] = v
138449
def updateRouterStatus(self):
        """"""
        print '%s call updateRouterStatus' % self.port
        cmd = 'state'
        while True:
            state = self.__sendCommand(cmd)[0]
            if state == 'detached':
                continue
            elif state == 'child':
                break
            else:
                return False

        cmd = 'state router'
        return self.__sendCommand(cmd)[0] == 'Done'
1050261
def _StatusUpdateThreadMain(self):
    """"""
    while self._status_update_active:
      # Make a local copy of the PIDs in case the dict is changed by
      # the main thread.
      for pid in list(self._process_information_per_pid.keys()):
        self._CheckStatusWorkerProcess(pid)

      self._UpdateForemanProcessStatus()

      tasks_status = self._task_manager.GetStatusInformation()
      if self._task_queue_profiler:
        self._task_queue_profiler.Sample(tasks_status)

      self._processing_status.UpdateTasksStatus(tasks_status)

      if self._status_update_callback:
        self._status_update_callback(self._processing_status)

      time.sleep(self._STATUS_UPDATE_INTERVAL)
433956
def update_pipeline(self, pipeline):
		'''
		'''
		#req sanity check
		payload = None
		if  type(pipeline) is not StreakPipeline:
			return requests.codes.bad_request, None

		payload = pipeline.to_dict(rw = True)

		try:
			uri = '/'.join([
						self.api_uri,
						self.pipelines_suffix,
						pipeline.attributes['pipelineKey']
						])
		except KeyError:
			return requests.codes.bad_request, None
	
		code, r_data = self._req('post', uri , json.dumps(payload))

		return code, r_data
607939
def update(self, **kwargs):
        
        if not self.object_id:
            return False

        url = self.build_url(
            self._endpoints.get('item').format(id=self.object_id))

        data = {self._cc(key): value for key, value in kwargs.items() if
                key in {'name',
                        'description'}}  # convert keys to protocol casing
        if not data:
            return False

        response = self.con.patch(url, data=data)
        if not response:
            return False

        new_data = response.json()

        for key in data:
            value = new_data.get(key, None)
            if value:
                setattr(self, self.protocol.to_api_case(key), value)

        return True
300560
def update(self, *args, **kwargs):
        '''
        
        '''
        preprocess = kwargs.get('preprocess')
        for s in args:
            for e in s:
                self._dict_set(preprocess(e) if preprocess else e, True)
103427
def update(self):
        
        logger.debug("")

        rd = self.repo_dir

        logger.debug("pkg path %s", rd)
        if not rd:
            print(
                "unable to find pkg '%s'. %s" % (self.name, did_u_mean(self.name))
            )

        cwd = os.getcwd()
        os.chdir(self.repo_dir)
        logger.debug("cwd: %s, updating %s ", cwd, self.repo_dir)
        try:
            p = git.pull('--rebase', '--progress',
                         _out=self._sh_stdout('blue'),
                         _err=self._sh_stderr('red'))
            p.wait()
        except Exception as e:
            pass
            # logger.warn(e)

        os.chdir(cwd)

        # Update or install any dependancies before running the
        # update script.
        self.install_update_deps()

        up = os.path.join(self.repo_dir, '_upkg', 'update')
        if os.path.exists(up):
            # We use subprocess instead of the sh module due to problems with
            # runing shell scripts with sh
            cwd = os.getcwd()
            os.chdir(os.path.join(self.repo_dir, '_upkg'))
            self.pr_info("Running update script for {} @ {}", self.name, up)
            subprocess.check_call(up, shell=True)
            os.chdir(cwd)
448018
def update(self,updates={}):
		
		try:
			csp = self.read()
		except:
			csp = {'default-src':"'self'"}
			self.write(csp)
		csp.update(updates)
		self.write(csp)