syck_parser_reset_levels
9632
public void resetLevels() {
        while(lvl_idx > 1) {
            popLevel();
        }

        if(lvl_idx < 1) {
            lvl_idx = 1;
            levels[0] = new Level();
            levels[0].spaces = -1;
            levels[0].ncount = 0;
            levels[0].domain = "";
        }
        levels[0].status = LevelStatus.header;
    }
1158183
public function reset() {
		$this->xml_depth = 0;
		unset($this->xmlobj);
		$this->xmlobj = array();
		$this->setupParser();
		if(!$this->is_server) {
			$this->send($this->stream_start);
		}
		$this->been_reset = true;
	}
666516
public void reset() {
		gsStack.removeAllElements();
		gsStack.add(new GraphicsState());
		textMatrix = null;
		textLineMatrix = null;
		resources = new DictionaryStack();
	}
789269
def reset(self):
        
        self.solved = False
        self.niter = 0
        self.iter_mis = []
        self.F = None
        self.system.dae.factorize = True
1108394
def reset(self):
        
        super(DruckSampler, self).reset()
        self.strata.reset()
        self._TP_st = np.zeros([self.strata.n_strata_, self._n_class])
        self._PP_st = np.zeros([self.strata.n_strata_, self._n_class])
        self._P_st = np.zeros([self.strata.n_strata_, self._n_class])
        self._TP_rates = np.zeros([self.strata.n_strata_, self._n_class])
        self._PP_rates = np.zeros([self.strata.n_strata_, self._n_class])
        self._P_rates = np.zeros([self.strata.n_strata_, self._n_class])

        for k in self.strata.indices_:
            for i in range(2):
                self._iterate(fixed_stratum = k, calc_rates = False)
201495
def clear_to_reset(self, config_vars):
        """"""

        super(BasicStreamingSubsystem, self).clear_to_reset(config_vars)
        self._in_progress_streamers = set()
1307774
private final void reset() {
	backtrackStack.clear();
	actionStack.clear();
	stateStack.clear();
	parserErrors.clear();
	streamPosition = 0;
	stepCounter = 0;
	stateStack.push(0);
	maxPosition = 0;
	shiftIgnoredTokens();
    }
784928
def _parse_reset(self, ref):
        """"""
        from_ = self._get_from()
        return commands.ResetCommand(ref, from_)
770488
def _reset(self):
        
        self._last_start_line = 0
        self._colour = None
        self._attr = None
        self._bg = None
        self._cur_x = None
        self._cur_y = None
1373869
def reset(self):
        
        self.p_lmbda = 0.0
        self.q_lmbda = 0.0
        self.mu_vmin = 0.0
        self.mu_vmax = 0.0
1336388
public static void reset() {
    SAXRule.numRules = new AtomicInteger(0);
    SAXSymbol.theDigrams.clear();
    SAXSymbol.theSubstituteTable.clear();
    SAXRule.arrRuleRecords = new ArrayList<GrammarRuleRecord>();
  }
138441
def reset
      err = Zlib.send @func_reset, pointer

      Zlib.handle_error err, message

      @flags = READY

      reset_input
    end
210002
def __flushLevel(self, level):
        """"""
        objectsCount = len(self.objectsStack)

        while objectsCount > level:
            lastIndex = objectsCount - 1
            if lastIndex == 0:
                # We have exactly one element in the stack
                if self.objectsStack[0].__class__.__name__ == "Class":
                    self.classes.append(self.objectsStack[0])
                else:
                    self.functions.append(self.objectsStack[0])
                self.objectsStack = []
                break

            # Append to the previous level
            if self.objectsStack[lastIndex].__class__.__name__ == "Class":
                self.objectsStack[lastIndex - 1].classes. \
                    append(self.objectsStack[lastIndex])
            else:
                self.objectsStack[lastIndex - 1].functions. \
                    append(self.objectsStack[lastIndex])

            del self.objectsStack[lastIndex]
            objectsCount -= 1
582883
def change_logger_levels(logger=None, level=logging.DEBUG):
    
    if not isinstance(logger, logging.Logger):
        logger = logging.getLogger(logger)

    logger.setLevel(level)
    for handler in logger.handlers:
        handler.level = level
1059299
def set_level(level):
    """"""
    for handler in HANDLERS:
        handler.setLevel(level)

    logging.root.setLevel(level)
597219
def reindent(tokens, indent=' '):
    
    old_levels = []
    old_level = 0
    new_level = 0
    for typ, tok, (start_row, start_col), (end_row, end_col), line in tokens:
        if typ == tokenize.INDENT:
            old_levels.append(old_level)
            old_level = len(tok)
            new_level += 1
            tok = indent * new_level
        elif typ == tokenize.DEDENT:
            old_level = old_levels.pop()
            new_level -= 1
        start_col = max(0, start_col - old_level + new_level)
        if start_row == end_row:
            end_col = start_col + len(tok)
        yield typ, tok, (start_row, start_col), (end_row, end_col), line
307621
public void reset() {
		for (int i = 0; i < 4; i++) {
			ppCorner.get(i).set(0,0);
			ppDown.get(i).set(0,0);
			ppRight.get(i).set(0,0);
		}
		this.threshCorner = 0;
		this.threshDown = 0;
		this.threshRight = 0;
		version = -1;
		error = L;
		mask = QrCodeMaskPattern.M111;
		alignment.reset();
		mode = Mode.UNKNOWN;
		failureCause = Failure.NONE;
		rawbits = null;
		corrected = null;
		message = null;
	}