Return a copy of this GeoRaster with no modifications.

        Can be use to create a Mutable copy of the GeoRaster
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)
518948
def clone(self, klass=None, memo=None, **kwargs):
        
        obj = Empty()
        obj.__class__ = klass or self.__class__

        obj.resource = self.resource

        obj.filters = self.filters.copy()
        obj.order_by = self.order_by

        obj.low_mark = self.low_mark
        obj.high_mark = self.high_mark

        obj.__dict__.update(kwargs)

        return obj
223216
def copy(self):
        
        return HyperCube(
            dimensions=self.dimensions(copy=False),
            arrays=self.arrays(),
            properties=self.properties())
188772
def copy_iterator(self):
        
        self.__udiff, iterator_copy = itertools.tee(self.__udiff)
        return iterator_copy
906408
def copy(self):
        """"""
        return self.__class__(self._key, self._load, self._iteritems())
524263
def copy(self):
		
		out = self._from_iterable(None)
		out._dict = self._dict.copy()
		out._size = self._size
		return out
1327771
def clone(self):
        
        from copy import copy
        clone = copy(self)
        clone.expr = copy(self.expr)
        clone.factory = False
        return clone
568436
def copy(self):
    
    if self._iters:
      a, b = it.tee(self._iters[0])
      self._iters[0] = a
      return Stream(b)
    iter(self)
294398
def clone(self, transformed=True):
        
        poly = self.polydata(transformed=transformed)
        polyCopy = vtk.vtkPolyData()
        polyCopy.DeepCopy(poly)

        cloned = Actor()
        cloned.poly = polyCopy
        cloned.mapper.SetInputData(polyCopy)
        cloned.mapper.SetScalarVisibility(self.mapper.GetScalarVisibility())
        pr = vtk.vtkProperty()
        pr.DeepCopy(self.GetProperty())
        cloned.SetProperty(pr)
        return cloned
203057
def copy(self):
        
        cls = self.__class__
        result = cls.__new__(cls)
        result._default_plugins = dict(self._default_plugins)  # pylint:disable=protected-access
        return result
27816
def copy(self):
        
        fs = self.__class__.__new__(self.__class__)
        fs.__dict__ = self.__dict__.copy()
        fs._frameSet = None
        if self._frameSet is not None:
            fs._frameSet = self._frameSet.copy()
        return fs
961919
def copy(self):
        ''' 
        '''
        m1 = Macaroon(None, None, version=self._version,
                      namespace=self._namespace)
        m1._macaroon = self._macaroon.copy()
        m1._caveat_data = self._caveat_data.copy()
        return m1
612856
def copy(self,deep=yes):
        
        if deep:
            return copy.deepcopy(self)
        else:
            return copy.copy(self)
836687
public T copy() {
        T ret = createLike();
        ret.getMatrix().set(this.getMatrix());
        return ret;
    }
645542
def copy(self):
        '''
        
        '''
        dup = super(Conditional, self).copy()
        condition = self._condition.copy()
        condition.invalidate(self)
        dup._condition = condition
        return dup
926327
def copy(self):
        
        new_prog = self.copy_everything_except_instructions()
        new_prog._instructions = self._instructions.copy()
        return new_prog
482813
def copy(self, deep=True):
        
        return self.__constructor__(query_compiler=self._query_compiler.copy())