reset: None -> None

        Resets the remote XBee device to a standard configuration
960510
def _reset(self):
        
        # Analog pin 0
        self.hw.remote_at(
            dest_addr=self.remote_addr,
            command='D0',
            parameter='\x02')

        # Disengage remote LED, buzzer
        self.deactivate()
        self._set_send_samples(False)
296985
def reset
      self.adapter        = DEFAULT_ADAPTER
      self.api_version    = DEFAULT_API_VERSION
      self.user_agent     = DEFAULT_USER_AGENT
      self.timeout        = DEFAULT_TIMEOUT
      self.open_timeout   = DEFAULT_TIMEOUT
      self.api_key        = nil
      self.proxy          = nil
    end
738908
def reset!
      self.client_id     = ENV['FIXER_CLIENT_ID']
      self.client_secret = ENV['FIXER_CLIENT_SECRET']
      self.adapter       = DEFAULT_ADAPTER
      self.endpoint      = ENV['FIXER_ENDPOINT'] || DEFAULT_ENDPOINT
      self.user_agent    = DEFAULT_USER_AGENT
      self.aws           = nil
      self.queue         = ENV['FIXER_QUEUE'] || DEFAULT_QUEUE
      self
    end
1348589
def reset!
      Artifactory::Configurable.keys.each do |key|
        instance_variable_set(:"@#{key}", Defaults.options[key])
      end
      self
    end
1305732
def emit_reset(self):
        """"""
        for name in self.layout.axes:
            params = self.layout.axes_options.get(name, DEFAULT_AXIS_OPTIONS)
            self.write_event(ecodes.EV_ABS, name, int(sum(params[1:3]) / 2))

        for name in self.layout.buttons:
            self.write_event(ecodes.EV_KEY, name, False)

        for name in self.layout.hats:
            self.write_event(ecodes.EV_ABS, name, 0)

        self.device.syn()
1065256
def reset_and_halt(self, reset_type=None):
        
        
        delegateResult = self.call_delegate('set_reset_catch', core=self, reset_type=reset_type)
        
        # halt the target
        if not delegateResult:
            self.halt()

        # Save CortexM.DEMCR
        demcr = self.read_memory(CortexM.DEMCR)

        # enable the vector catch
        if not delegateResult:
            self.write_memory(CortexM.DEMCR, demcr | CortexM.DEMCR_VC_CORERESET)

        self.reset(reset_type)

        # wait until the unit resets
        with timeout.Timeout(2.0) as t_o:
            while t_o.check():
                if self.get_state() not in (Target.TARGET_RESET, Target.TARGET_RUNNING):
                    break
                sleep(0.01)

        # Make sure the thumb bit is set in XPSR in case the reset handler
        # points to an invalid address.
        xpsr = self.read_core_register('xpsr')
        if xpsr & self.XPSR_THUMB == 0:
            self.write_core_register('xpsr', xpsr | self.XPSR_THUMB)

        self.call_delegate('clear_reset_catch', core=self, reset_type=reset_type)

        # restore vector catch setting
        self.write_memory(CortexM.DEMCR, demcr)
954403
def reset(self):
        
        self.wf.fill(0)
        self.wf[(0,) * self.n_qubits] = complex(1.0, 0)
        return self
894967
public void reset()
      throws SISessionUnavailableException, SISessionDroppedException,
             SIConnectionUnavailableException, SIConnectionDroppedException,
             SIResourceException, SIConnectionLostException,
             SIErrorException
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "reset");

      SIErrorException e = new SIErrorException(
         nls.getFormattedMessage("PROTOCOL_ERROR_SICO2003", null,null)
      );

      FFDCFilter.processException(e, CLASS_NAME + ".reset",
                                  CommsConstants.CATCONSUMER_RESET_01,
                                  this);

      SibTr.error(tc, "PROTOCOL_ERROR_SICO2003", e);

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "reset");

      // Re-throw this exception so that the client will informed if required
      throw e;
   }
615675
def reset(self, uuid):
        
        args = {
            'uuid': uuid,
        }
        self._domain_action_chk.check(args)

        self._client.sync('kvm.reset', args)
1072
def reset(stick):
    
    nulls = (pyhsm.defines.YSM_MAX_PKT_SIZE - 1) * '\x00'
    res = YHSM_Cmd(stick, pyhsm.defines.YSM_NULL, payload = nulls).execute(read_response = False)
    unlock = stick.acquire()
    try:
        stick.drain()
        stick.flush()
    finally:
        unlock()
    return res == 0
609333
def config(self, settings):
        
        self.debug("()")
        # TODO synchronize access to vars
        try:
            self._device_id = settings['device_id']

            self._packet_timeout = settings.get(
                'packet_wait_timeout',
                self._packet_timeout
            )
            self._server_ip = settings.get('server_ip', self._server_ip)
            self._server_port = settings.get('server_port', self._server_port)
        except KeyError:
            raise SensorUpdateException("Key not in settings")

        if callable(self.on_config):
            try:
                self.on_config(settings)
            except:
                self.exception("Failed to update remote config")
                raise SensorUpdateException("Remote config failed")
726148
def reset(self, rg=None):
        '''
        
        '''
        if type(rg) == int:
            rg= [rg]
        to_reset= rg if rg else self.__get_ranges("present")
        self.enable_cpu(to_reset)
        for cpu in to_reset:
            fpath = path.join("cpu%i"%cpu,"cpufreq","cpuinfo_max_freq")
            max_freq = self.__read_cpu_file(fpath)
            fpath = path.join("cpu%i"%cpu,"cpufreq","cpuinfo_min_freq")
            min_freq = self.__read_cpu_file(fpath)

            fpath = path.join("cpu%i"%cpu,"cpufreq","scaling_max_freq")
            self.__write_cpu_file(fpath, max_freq.encode())
            fpath = path.join("cpu%i"%cpu,"cpufreq","scaling_min_freq")
            self.__write_cpu_file(fpath, min_freq.encode())
37702
def reset(self):
        

        def fail(metadata):
            raise ProtocolError("RESET failed %r" % metadata)

        log_debug("[#%04X]  C: RESET", self.local_port)
        self._append(b"\x0F", response=Response(self, on_failure=fail))
        self.sync()
220572
def reset
      self.api_key            = DEFAULT_API_KEY
      self.api_id             = DEFAULT_API_ID
      self.adapter            = DEFAULT_ADAPTER
      self.connection_options = DEFAULT_CONNECTION_OPTIONS
      self.endpoint           = DEFAULT_ENDPOINT
      self.format             = DEFAULT_FORMAT
      self.proxy              = DEFAULT_PROXY
      self.user_agent         = DEFAULT_USER_AGENT
    end
439721
public void reset() throws InvalidOperationException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reset");

    InvalidOperationException e = new InvalidOperationException(
      nls.getFormattedMessage(
        "OPERATION_IS_INVALID_ERROR_CWSIP0121",
        new Object[] { getName(), getBus() },
      null));

    SibTr.exception(tc, e);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())    
      SibTr.exit(tc, "reset", e);
      
    throw e;    
  }
844375
def resetn(self):
        
        #Regular reset will kick NRF out of DBG mode
        logging.debug("target_nrf51.reset: enable reset pin")
        self.write_memory(RESET, RESET_ENABLE)
        #reset
        logging.debug("target_nrf51.reset: trigger nRST pin")
        self.reset()
1003051
def reset(self, **kwargs):
    
    self.env.reset(**kwargs)
    if self.override_num_noops is not None:
      noops = self.override_num_noops
    else:
      noops = self.unwrapped.np_random.randint(1, self.noop_max + 1)  # pylint: disable=E1101
    assert noops > 0
    obs = None
    for _ in range(noops):
      obs, _, done, _ = self.env.step(self.noop_action)
      if done:
        obs = self.env.reset(**kwargs)
    return obs