Replace existing cls.reset() method with a new one which also
    calls reset() on any clones.
11831
def add_new_reset_method(cls):
    
    orig_reset = cls.reset

    def new_reset(self, seed=None):
        logger.debug(f"Calling reset() on {self} (seed={seed})")
        orig_reset(self, seed)
        for c in self._dependent_generators:
            c.reset_dependent_generator(seed)
        return self

    cls.reset = new_reset
577922
def reset(self, seed):
        
        logger.debug(f'Resetting {self} (seed={seed})')
        self.seed_generator.reset(seed)

        for c in self.clones:
            c.reset(seed)
225521
def _update_classmethod(self, oldcm, newcm):
        """"""
        # While we can't modify the classmethod object itself (it has no
        # mutable attributes), we *can* extract the underlying function
        # (by calling __get__(), which returns a method object) and update
        # it in-place.  We don't have the class available to pass to
        # __get__() but any object except None will do.
        self._update(None, None, oldcm.__get__(0), newcm.__get__(0))
1242229
def _reset_changes(self):
        """"""
        self._original = {}
        if self.last_updated is not None:
            self._original['last_updated'] = self.last_updated
76865
public void reset() {
    lastReset = new Date();

    if (counters != null) {
      synchronized (counters) {
        counters.clear();
      }
    }

    if (chronos != null) {
      synchronized (chronos) {
        chronos.clear();
      }
    }

    if (stats != null) {
      synchronized (stats) {
        stats.clear();
      }
    }
  }
1200017
public ClassReloadingStrategy reset(ClassFileLocator classFileLocator, Class<?>... type) throws IOException {
        if (type.length > 0) {
            try {
                strategy.reset(instrumentation, classFileLocator, Arrays.asList(type));
            } catch (ClassNotFoundException exception) {
                throw new IllegalArgumentException("Cannot locate types " + Arrays.toString(type), exception);
            } catch (UnmodifiableClassException exception) {
                throw new IllegalStateException("Cannot reset types " + Arrays.toString(type), exception);
            }
        }
        return this;
    }
1015343
def reset(cls):
        
        cls.debug = False
        cls.disabled = False
        cls.overwrite = False
        cls.playback_only = False
        cls.recv_timeout = 5
        cls.recv_endmarkers = []
        cls.recv_size = None
419805
def replace(self, repl_class, replacement, target_segment_name=None):
        """"""

        for segment_name, pipes in iteritems(self):

            if target_segment_name and segment_name != target_segment_name:
                raise Exception()

            repl_pipes = []
            found = False
            for pipe in pipes:
                if isinstance(pipe, repl_class):
                    pipe = replacement
                    found = True

                repl_pipes.append(pipe)

            if found:
                found = False
                self[segment_name] = repl_pipes
1200995
def reset(self):
        '''
        
        '''
        t = self
        while t._output is not None:
            t = t._output
        while t is not None:
            if t._pop and t._pop.returncode is None:
                t._pop.kill()
                t._pop.wait()
            del t._pop
            t._pop = None
            t = t._input
        return self
545555
def reset(self, lineno=None, offset=None, type_=None):
        
        self.lineno = self.lineno if lineno is None else lineno
        self.type_ = self.type_ if type_ is None else type_
        self.offset = self.offset if offset is None else offset

        self.callable = True
        self.params = SymbolPARAMLIST()
        self.body = SymbolBLOCK()
        self.__kind = KIND.unknown
        self.local_symbol_table = None
563529
public void reset() {
    this.result = UNDEF;
    this.var2index = new TreeMap<>();
    this.index2var = new TreeMap<>();
    switch (this.algorithm) {
      case WBO:
        this.solver = new WBO(this.configuration);
        break;
      case INC_WBO:
        this.solver = new IncWBO(this.configuration);
        break;
      case LINEAR_SU:
        this.solver = new LinearSU(this.configuration);
        break;
      case LINEAR_US:
        this.solver = new LinearUS(this.configuration);
        break;
      case MSU3:
        this.solver = new MSU3(this.configuration);
        break;
      case WMSU3:
        this.solver = new WMSU3(this.configuration);
        break;
      default:
        throw new IllegalArgumentException("Unknown MaxSAT algorithm: " + this.algorithm);
    }
  }
170655
@Override
	public void reset() {
		this.priorityElements = Lists.newArrayList(originalElements);
		Collections.shuffle(priorityElements);
		this.currentElements = Lists.newArrayListWithExpectedSize(2 * originalElements.size());
		this.currentElements.addAll(originalElements);
	}
758624
def reset(cls):
        
        cls.hide()

        cls.values = None
        cls.filename = "fn"
        cls.dc_out_el.text = ""
        cls.oai_out_el.text = ""
        cls.mrc_out_el.text = ""
786435
def copy(self, **replacements):
    """"""
    cls = type(self)
    kwargs = {'org': self.org, 'name': self.name, 'ext': self.ext, 'classifier': self.classifier, 'rev': self.rev}
    for key, val in replacements.items():
      kwargs[key] = val
    return cls(**kwargs)
1112023
public void reset() {
    FLog.v(TAG, "reset");
    mGestureDetector.reset();
    mPreviousTransform.reset();
    mActiveTransform.reset();
    onTransformChanged();
  }
875597
def reset(self):
        '''  '''

        # reset the main stream
        if self.stream:
            self.stream.reset()

        # reset the initial stream (otherwise old 'adds' remain in the new stream)
        if self.initial_stream:
            self.initial_stream.reset()
1305101
def reset(cls, *args, **kwargs):
        """"""
        cls.local.tchannel = None
        cls.args = None
        cls.kwargs = None
        cls.prepared = False