Clone this generator with the exact same options.
508014
def clone(self, fp):
        """"""
        return self.__class__(fp,
                              self._mangle_from_,
                              None, # Use policy setting, which we've adjusted
                              policy=self.policy)
708689
@Override
    public ModelNode cloneModel()
    {
        int len = mSubModels.length;
        ModelNode[] newModels = new ModelNode[len];
        for (int i = 0; i < len; ++i) {
            newModels[i] = mSubModels[i].cloneModel();
        }
        return new ChoiceModel(newModels);
    }
110582
def _clone_properties(self):
    """"""
    cls = self.__class__
    if self._properties is cls._properties:
      self._properties = dict(cls._properties)
806709
def clone(self):
        
        self._dlog("cloning the stack")
        # TODO is this really necessary to create a brand new one?
        # I think it is... need to think about it more.
        # or... are we going to need ref counters and a global
        # scope object that allows a view into (or a snapshot of)
        # a specific scope stack?
        res = Scope(self._log)
        res._scope_stack = self._scope_stack
        res._curr_scope = self._curr_scope
        return res
1361510
def clone(self):
		
		snapshot = DistributionSnapshot(self.distribution(), self.go_version)
		for package in self.builds:
			snapshot.setRpms(package, self.builds[package]["build"], self.builds[package]["build_ts"], self.builds[package]["rpms"])

		return snapshot
902040
def clone(cls, srcpath, destpath, encoding='utf-8'):
        """"""
        cmd = [GIT, 'clone', '--quiet', '--bare', srcpath, destpath]
        subprocess.check_call(cmd)
        return cls(destpath, encoding)
72130
def clone(self, config, **kwargs):
        """"""
        gta = GTAnalysis(config, **kwargs)
        gta._roi = copy.deepcopy(self.roi)
        return gta
806927
public TupleCombiner cloneOf()
    {
    TupleCombiner other = new TupleCombiner();
    other.setTupleSize( getTupleSize());
    other.setIncludedVars( new HashSet<VarNamePattern>( getIncludedVars()));
    other.setExcludedVars( new HashSet<VarNamePattern>( getExcludedVars()));
    other.setOnceTuples( new HashSet<TupleRef>( IteratorUtils.toList( getOnceTuples())));
    return other;
    }
1091323
def clone(self, name=None):
    
    if name is None:
      name = self.module_name + "_clone"
    return Linear(output_size=self.output_size,
                  use_bias=self._use_bias,
                  initializers=self._initializers,
                  partitioners=self._partitioners,
                  regularizers=self._regularizers,
                  name=name)
786222
public DTMIterator cloneWithReset() throws CloneNotSupportedException
  {

    OneStepIterator clone = (OneStepIterator) super.cloneWithReset();
    clone.m_iterator = m_iterator;

    return clone;
  }
1194081
def clone(self, choices):
        
        return self.__class__(
            self.name,
            choices,
            self.label,
            self.description,
            self.multiple,
            self.viewFactory)
926327
def copy(self):
        
        new_prog = self.copy_everything_except_instructions()
        new_prog._instructions = self._instructions.copy()
        return new_prog
442076
def copy(self):
        """"""
        o = self.__class__(self.project, self.name)
        Scriptable.copy(self, o)
        o.position = tuple(self.position)
        o.direction = self.direction
        o.rotation_style = self.rotation_style
        o.size = self.size
        o.is_draggable = self.is_draggable
        o.is_visible = self.is_visible
        return o
284116
def generate(self):
        """"""
        key = self._propose_new_key()
        while self.key_exists(key):
            _logger.warning('Previous candidate was used.'
                            ' Regenerating another...')
            key = self._propose_new_key()
        return key
419800
def copy(self):
        """"""
        other = Version(None)
        other.tokens = self.tokens[:]
        other.seps = self.seps[:]
        return other
359431
def clone(self, callable=None, **overrides):
        
        old = {k: v for k, v in self.get_param_values()
               if k not in ['callable', 'name']}
        params = dict(old, **overrides)
        callable = self.callable if callable is None else callable
        return self.__class__(callable, **params)
117092
def clone(self) -> "Event":
        
        return self.__class__(copy.deepcopy(self.event), copy.deepcopy(self.metadata))