Reset logger to its initial state.
492694
def _set_defaults(self, log_level=logging.INFO, redirect_stdout=False):
        """"""

        # Remove all previous handlers
        for handler in self.handlers[:]:
            self.removeHandler(handler)

        # Set levels
        self.setLevel(logging.DEBUG)

        # Set up the stdout handler
        self.fh = None
        self.sh = logging.StreamHandler()
        self.sh.emit = colored_formatter
        self.addHandler(self.sh)

        self.sh.setLevel(log_level)

        # warnings.showwarning = self._show_warning

        # Redirects all stdout to the logger
        if redirect_stdout:
            sys.stdout = LoggerStdout(self._print)

        # Catches exceptions
        sys.excepthook = self._catch_exceptions
1315764
def _reset(self):
        """"""
        self._in_declare = False
        self._is_create = False
        self._begin_depth = 0

        self.consume_ws = False
        self.tokens = []
        self.level = 0
670235
def reset(self):
        """"""
        self.counts = defaultdict(partial(np.zeros, (465, self.tmax * 2 + 1)))
        self.n_timeslices = defaultdict(int)
594484
def reset(self):
        
        if self._retrigger_value is not NONE:
            self.notify(self._retrigger_value)
            self._state = self._retrigger_value
            self._next_state = self._retrigger_value
        if self._call_later_handler:
            self._call_later_handler.cancel()
            self._call_later_handler = None
583622
def initialize_logging(self):
        """"""
        # Reset logging to pass logrecords into the queue to the frontend only.
        # Existing handlers may be broken as they were copied into a new process,
        # so should be discarded.
        for loggername in [None] + list(logging.Logger.manager.loggerDict.keys()):
            logger = logging.getLogger(loggername)
            while logger.handlers:
                logger.removeHandler(logger.handlers[0])

        # Re-enable logging to console
        root_logger = logging.getLogger()

        # By default pass all warning (and higher) level messages to the frontend
        root_logger.setLevel(logging.WARN)
        root_logger.addHandler(workflows.logging.CallbackHandler(self._log_send))

        # Set up the service logger and pass all info (and higher) level messages
        # (or other level if set differently)
        self.log = logging.getLogger(self._logger_name)

        if self.start_kwargs.get("verbose_log"):
            self.log_verbosity = logging.DEBUG
        self.log.setLevel(self.log_verbosity)

        # Additionally, write all critical messages directly to console
        console = logging.StreamHandler()
        console.setLevel(logging.CRITICAL)
        root_logger.addHandler(console)
1198198
def reset(cls):
        """"""
        cls._disable_faulthandler()
        if cls.handlers is not None:
            for handler in cls.handlers:
                logging.root.removeHandler(handler)
            cls.handlers = None
        cls._logging_snapshot.restore()
        cls.context.reset()
        cls.spec = LogSpec(cls._default_spec)
        cls.debug = None
        cls.actual_location = None
        cls.console_handler = None
        cls.file_handler = None
        cls.used_formats = None
1011802
void clear() {

        // This is volatile, read once for performance.
        final String name = loggerName;
        if (name != null) {
            CHANGE_LOGGER_CONTEXT_LOCK.lock();
            try {
                loggerContext.stop();

                final Logger logger = loggerContext.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
                logger.detachAndStopAllAppenders();

                // Additional cleanup/reset for this name
                configureLoggers(name);
            } finally {
                CHANGE_LOGGER_CONTEXT_LOCK.unlock();
            }

            StatusPrinter.setPrintStream(System.out);
        }
    }
607853
def reset(self):
        
        super(SinonSpy, self).unwrap()
        super(SinonSpy, self).wrap2spy()
949349
def log_starting(self):
		""""""
		self.start_time = time.perf_counter()
		logger.log("Starting '", logger.cyan(self.name), "'...")
808468
public void reset() {
		this.errorType = ErrorType.NONE;
		this.message = null;
		this.columnName = null;
		this.columnValue = null;
		this.columnType = null;
		this.line = null;
		this.lineNumber = 0;
		this.linePos = 0;
	}
594195
def reset(self):
        '''
        
        '''
        self.resetRNG()
        sNow = np.zeros(self.pop_size)
        Shk  = self.RNG.rand(self.pop_size)
        sNow[Shk < self.p_init] = 1
        self.sNow = sNow
163644
public void reset()
	{
		if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
			logger.logp(Level.FINE, CLASS_NAME,"reset", "reset");
        }
		out = null;
		// obs = null;
		count = 0;
		total = 0;
		limit = -1;
		length = -1;
		committed = false;
		_hasWritten = false;
		_hasFlushed = false;
		except = null;
		response = null;
		if(WCCustomProperties.FINISH_RESPONSE_ON_CLOSE) //PK89810
					outputstreamClosed = false;
	}
829708
def reset(self):
        

        self.stream.write(self.normal_cursor)
        self.stream.write(self.csr(0, self.height))
        self.stream.write(self.move(self.height, 0))
109997
def set_logger(self):
        
        self.logger = logging.getLogger(self.logger_name)
        self.logger.setLevel(self.logger_level)
584926
def reset():
    
    if hasattr(ray.worker.global_worker, "signal_counters"):
        ray.worker.global_worker.signal_counters = defaultdict(lambda: b"0")
294845
void reset() {
    logger = null;
    level = Level.DEBUG;
    marker = null;
    startTime = -1L;
    startNanos = -1L;
    latency = -1L;
    owner = null;
    result = null;
    protocol = null;
    status = null;
    statusDetail = null;
    exception = null;
    attempt = null;
    attemptFinal = null;
    vip = null;
    endpoint = null;
    clientRegion = null;
    clientZone = null;
    clientApp = null;
    clientCluster = null;
    clientAsg = null;
    clientNode = null;
    serverRegion = null;
    serverZone = null;
    serverApp = null;
    serverCluster = null;
    serverAsg = null;
    serverNode = null;
    httpMethod = null;
    httpStatus = -1;
    uri = null;
    path = null;
    requestHeaders.clear();
    responseHeaders.clear();
    remoteAddress = null;
    remotePort = -1;
    additionalTags.clear();
    builder.delete(0, builder.length());
    inflightId = null;
  }
767077
def reset(self):
        """"""
        self.at(ardrone.at.ref, False, True)
        time.sleep(0.1)
        self.at(ardrone.at.ref, False, False)