Copy constructor.
199664
def copy(self):
        
        return self._constructor(values=self._codes.copy(),
                                 dtype=self.dtype,
                                 fastpath=True)
419800
def copy(self):
        """"""
        other = Version(None)
        other.tokens = self.tokens[:]
        other.seps = self.seps[:]
        return other
370538
def copy(self):
        """"""
        o = self.__class__(self.target,
                self.block.copy(),
                self.style,
                self.is_visible,
                self.pos)
        o.slider_min = self.slider_min
        o.slider_max = self.slider_max
        return o
646385
def make_copy(cls, generator):
        
        return from_commandline(
            to_commandline(generator), classname=classes.get_classname(DataGenerator()))
499775
def copy(self, mutable=False):
        """"""

        if self.not_loaded():
            _cls = self.__class__
            if mutable:
                _cls = MutableGeoRaster
            return _cls.open(self._filename)

        return self.copy_with(mutable=mutable)
124024
def _generate_constructor(cls, names):
        """"""

        cache = cls._constructors
        if names in cache:
            return cache[names]
        elif len(cache) > 3:
            cache.clear()

        func = generate_constructor(cls, names)
        cache[names] = func
        return func
192534
function clone (obj){
	if(obj == null || typeof(obj) != 'object')
		return obj;

	var temp = obj.constructor();

	for(var key in obj)
		temp[key] = clone(obj[key]);
	return temp;
}
84306
function Copy(src, withAccess) {
  if (!(this instanceof Copy)) return new Copy(src, withAccess);
  this.src = src;
  this._withAccess = withAccess;
}
1125874
def copy(self, overrides=None, locked=False):
        """"""
        other = copy.copy(self)

        if overrides is not None:
            other.overrides = overrides

        other.locked = locked

        other._uncache()
        return other
271517
public void copy(Program that) {
      operatorSet.copy(that.operatorSet);
      variableSet.copy(that.variableSet);
      constantSet.copy(that.constantSet);
      depth = that.depth;
      length = that.length;

      if(that.root != null) {
         root = that.root.makeCopy(operatorSet, variableSet, constantSet);
      } else {
         root = null;
      }
   }
925444
function copy(obj) {
  var filters = copy.filterFactory(obj.filter);
  var source = copy.sourceFactory(obj.source, filters);
  var dest = copy.destFactory(obj.dest, filters);
  dest.processSource(source);
}
617390
def copy(defaults={}, context={})
      self.class.find(rpc_execute('copy', id, defaults, context), context: context)
    end
817776
def copy(self):
        
        return self.__class__(self.x, self.y, *self._args, **self._kwargs)
15064
function copy(target, obj) {
  if (isObject(obj)) {
    forIn(obj, function(value, key) {
      target[key] = value;
    });
  }
}
332525
def copy_from(self, other):
        """"""
        self.verbose, self.quiet, self.path, self.name, self.tracing = other.verbose, other.quiet, other.path, other.name, other.tracing
922211
def copy(self):
        """"""
        params = {}
        for key, val in self.__dict__.items():
            if 'matrix' not in key:
                k = key[1:] if key[0] == '_' else key
                params[k] = val
        # params = {param: params[param] for param in params}
        return self.__class__(**params)
650308
private void copy() {
        if (elems.nonEmpty()) {
            List<A> orig = elems;

            elems = last = List.of(orig.head);

            while ((orig = orig.tail).nonEmpty()) {
                last.tail = List.of(orig.head);
                last = last.tail;
            }
        }
    }