Check if the settings data has been loaded.
769545
protected function checkLoaded()
	{
		if ( ! $this->modified ) {
		//	$this->storage = json_decode(json_encode($this->read()), true);
			$this->storage  = $this->read();
			$this->modified = true;
		}
	}
671815
def check_settings(self, settings):
        
        assert isinstance(settings, dict)

        errors = []
        if not isinstance(settings, dict) or len(settings) == 0:
            errors.append('invalid_syntax')
        else:
            if not self.__sp_validation_only:
                errors += self.check_idp_settings(settings)
            sp_errors = self.check_sp_settings(settings)
            errors += sp_errors

        return errors
1143638
async def settings(dev: Device):
    """"""
    settings_tree = await dev.get_settings()

    for module in settings_tree:
        await traverse_settings(dev, module.usage, module.settings)
102087
def check(self):
        """"""

        if len(self.status_datasets) == 0:
            return False
        if all(self.status_datasets):
            return True
        return False
87530
def __load_settings(self):
        
        #file_path = path.relpath(settings_file_path)
        #file_path = path.abspath(settings_file_path)
        file_path = self.file_path

        try:
            self.data = json.load(open(file_path))
        except FileNotFoundError:
            print("Could not load", file_path)
885407
def check(self, check_all=True, do_reload=True):
        """"""
        with enaml.imports():
            super(EnamlReloader, self).check(check_all=check_all, do_reload=do_reload)
1203098
function shouldShowWidget(settings = {}) {
  const nowDate = new Date();
  // Show widget if flag does not exist (old widgets)
  if (!settings.hasOwnProperty('published')) {
    return true;
  }

  if (settings.published === false) {
    return false;
  }

  // Defensive here since this data comes from the pipeline, it might be invalid for some reasons.
  if (settings.hasOwnProperty('plan') && settings.plan) {
    let startDate = null;
    let endDate = null;
    let notStartedYet = false;
    let finishedAlready = false;

    if (settings.planDate.valid_from) {
      startDate = new Date(settings.planDate.valid_from);
      notStartedYet = nowDate <= startDate;
    }

    if (settings.planDate.valid_to) {
      endDate = new Date(settings.planDate.valid_to);
      finishedAlready = nowDate >= endDate;
    }
    // Don't hide if no dates found
    if (!startDate && !endDate) {
      return true;
    }

    // Hide if some wrong dates are passed
    if (startDate && endDate && (startDate >= endDate)) {
      return false;
    }

    // Hide if start date is set but it is not there yet
    // Hide if end date is reached
    if ((startDate && notStartedYet) || (endDate && finishedAlready)) {
      return false;
    }
  }

  return true;
}
205932
def restoreSettings( self, settings ):
        
        dataSet = self.dataSet()
        if ( not dataSet ):
            return False
        
        projexui.restoreDataSet( settings,
                                 self.uniqueName(),
                                 dataSet )
        
        if ( not self.signalsBlocked() ):
            self.restoreFinished.emit()
        
        return True
627264
def _get_settings(self):
        """"""
        url = self._global_settings_url
        payload = {}
        res = self._send_request('GET', url, payload, 'settings')
        if res and res.status_code in self._resp_ok:
            return res.json()
1013099
def load_settings(self, settings):
        """"""
        with open(settings) as settings_file:
            settings_dict = simplejson.load(settings_file)
        for key, value in settings_dict.items():
            self.__setattr__(key, value)
808871
def _CheckData(yaml_data):
  """"""
  legal_keys = set(('blacklist', 'whitelist'))
  unknown_keys = set(yaml_data) - legal_keys
  if unknown_keys:
    raise UnknownConfigKeyError(
        'Unknown keys in configuration: %s' % unknown_keys)

  for key, data in six.iteritems(yaml_data):
    _AssertDataIsList(key, data)
798036
function(key, data) {
        var currentData;
        currentData = settings[key];
        if ((currentData != null) && _.isObject(currentData)) {
          settings[key] = _.extend(data, settings[key]);
        } else if (currentData == null) {
          settings[key] = data;
        }
      }
1192254
def is_displayed(self):
        
        t = self.wait_timeout
        self.wait_timeout = 0
        try:
            self.reload()
            return any(e.is_displayed() for e in self)
        finally:
            self.wait_timeout = t
225385
protected function checkSettings()
    {
        if (empty($this->settings['additional']['detailPid'])) {
            $this->settings['additional']['detailPid'] = $GLOBALS['TSFE']->id;
        }

        if (empty($this->settings['additional']['listPid'])) {
            $this->settings['additional']['listPid'] = $GLOBALS['TSFE']->id;
        }

        if (empty($this->settings['associationID'])) {
            $this->addFlashMessage(
          'Please set a association',
          'Configuration Error',
          FlashMessage::ERROR
        );
        }
    }
842969
function setLoading(value) {
    if (ctrl.loading !== value) {
      ctrl.loading = value;
    }

    // Always refresh the hidden variable as something else might have changed
    ctrl.hidden = shouldHide();
  }
967527
protected function checkLazyLoad()
    {
        if ($this->lazyLoadInitiated === true) {
            return;
        }

        $this->lazyLoad();
        $this->generateKeys();

        $this->lazyLoadInitiated = true;
    }
1272840
def available_settings(self):
        """"""
        available = {}
        if not self.status_data:
            return available

        for (key, val) in self.status_data.get('avail', {}).items():
            available[key] = []
            for subval in val:
                try:
                    subval = float(subval)
                except ValueError:
                    subval = subval

                if val in ('on', 'off'):
                    subval = (subval == 'on')

                available[key].append(subval)

        return available