Reset secure boot keys to manufacturing defaults.

        :raises: IloError, on an error from iLO.
        :raises: IloCommandNotSupportedError, if the command is not supported
                 on the server.
338669
def reset_secure_boot_keys(self):
        
        if self._is_boot_mode_uefi():
            self._change_secure_boot_settings('ResetToDefaultKeys', True)
        else:
            msg = ('System is not in UEFI boot mode. "SecureBoot" related '
                   'resources cannot be changed.')
            raise exception.IloCommandNotSupportedInBiosError(msg)
772842
def reset
      self.consumer_key       = DEFAULT_CONSUMER_KEY
      self.consumer_secret    = DEFAULT_CONSUMER_SECRET
      self.oauth_token        = DEFAULT_OAUTH_TOKEN
      self.oauth_token_secret = DEFAULT_OAUTH_TOKEN_SECRET
      self.endpoint           = DEFAULT_ENDPOINT
      self.user_agent         = DEFAULT_USER_AGENT
      self.timeout            = DEFAULT_TIMEOUT
      self
    end
1117513
def internal_reset(self):
        
        log.critical("PIA internal_reset()")
        self.empty_key_toggle = True
        self.current_input_char = None
        self.input_repead = 0
1303916
def _reset(self):
        
        # Reset DataContainer to default values
        # So that it can be reused
        if self.logger: # pragma: no cover
            self.logger.info("Reset DataContainer")
        self._items_list = []
        self._config.data_type = None
31776
def enforce_reset(self):
        

        ub = (self.ubnd * (1.0+self.bound_tol)).to_dict()
        lb = (self.lbnd * (1.0 - self.bound_tol)).to_dict()
        #for iname,name in enumerate(self.columns):
            #self.loc[self.loc[:,name] > ub[name],name] = ub[name] * (1.0 + self.bound_tol)
            #self.loc[self.loc[:,name] < lb[name],name] = lb[name].copy() * (1.0 - self.bound_tol)
        #    self.loc[self.loc[:,name] > ub[name],name] = ub[name]
        #    self.loc[self.loc[:,name] < lb[name],name] = lb[name]

        val_arr = self.values
        for iname, name in enumerate(self.columns):
            val_arr[val_arr[:,iname] > ub[name],iname] = ub[name]
            val_arr[val_arr[:, iname] < lb[name],iname] = lb[name]
732031
def factory_reset(self, ids, except_ids=False, except_baudrate_and_ids=False):
        

        mode = (0x02 if except_baudrate_and_ids else
                0x01 if except_ids else 0xFF)

        for id in ids:
            try:
                self._send_packet(self._protocol.DxlResetPacket(id, mode))

            except (DxlTimeoutError, DxlCommunicationError):
                pass
949518
private void resetBaseUnrecoverability()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "resetBaseUnrecoverability", this);

        _unrecoverableOptions = _baseUnrecoverableOptions;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "resetBaseUnrecoverability");
    }
421781
def _reset(self):
        
        self.path = ''
        self.version = ''
        self.release = ''
        self.is_signed = False
        self.is_synced = False
        self.rpm = False
261811
def get_allowed_reset_keys_values(self):
        
        reset_keys_action = self._get_reset_keys_action_element()

        if not reset_keys_action.allowed_values:
            LOG.warning('Could not figure out the allowed values for the '
                        'reset keys in secure boot %s', self.path)
            return set(mappings.SECUREBOOT_RESET_KEYS_MAP_REV)

        return set([mappings.SECUREBOOT_RESET_KEYS_MAP[v] for v in
                    set(mappings.SECUREBOOT_RESET_KEYS_MAP).
                    intersection(reset_keys_action.allowed_values)])
1184200
def set_secure_boot_mode(irmc_info, enable):
    

    bios_config_data = {
        'Server': {
            '@Version': '1.01',
            'SystemConfig': {
                'BiosConfig': {
                    '@Version': '1.01',
                    'SecurityConfig': {
                        'SecureBootControlEnabled': enable
                    }
                }
            }
        }
    }
    restore_bios_config(irmc_info=irmc_info, bios_config=bios_config_data)
1146491
public void resetToDefaults()
    {
        gatekeeper.signIn();
        try
        {
            for (Iterator<Entry<String, ChangeStack<String>>> iter = properties.entrySet()
                                                                               .iterator(); iter.hasNext();)
            {
                Entry<String, ChangeStack<String>> entry = iter.next();

                String defaultValue = getDefaultValue(entry.getKey());
                if (defaultValue == null)
                {
                    iter.remove();
                    continue;
                }

                entry.getValue().push(defaultValue);
            }
        }
        finally
        {
            gatekeeper.signOut();
        }
    }
551924
def reset(self, configuration: dict) -> None:
        
        self.clean(0)
        self.backend.store_config(configuration)
679692
def reset_catalog():
    '''
    
    '''
    # This command always returns an error code, though it completes
    # successfully. Success will be determined by making sure get_catalog
    # returns 'Default'
    cmd = ['softwareupdate', '--clear-catalog']

    try:
        salt.utils.mac_utils.execute_return_success(cmd)
    except CommandExecutionError as exc:
        pass

    return get_catalog() == 'Default'
604201
def reset(type = 'cold')
      if ['cold', 'warm'].include?(type)
        key = "#{type}-reset"
        command(key)
      else
        logger.error("reset type: #{type} is not a valid choice, use warm or cold") if logger
        raise "reset type: #{type} is not a valid choice, use warm or cold"
      end
    end
1373869
def reset(self):
        
        self.p_lmbda = 0.0
        self.q_lmbda = 0.0
        self.mu_vmin = 0.0
        self.mu_vmax = 0.0
419193
def unset_iscsi_info(self):
        
        if(self._is_boot_mode_uefi() is True):
            iscsi_info = {'iSCSIBootEnable': 'Disabled'}
            self._change_iscsi_settings(iscsi_info)
        else:
            msg = 'iSCSI boot is not supported in the BIOS boot mode'
            raise exception.IloCommandNotSupportedInBiosError(msg)
157523
def _reset_server_state(self) -> None:
        
        self.last_helo_response = None
        self._last_ehlo_response = None
        self.esmtp_extensions = {}
        self.supports_esmtp = False
        self.server_auth_methods = []