Return a copy of the resource with same raw data

        :return: copy of the resource
335464
def shadow_copy(self):
        
        ret = self.__class__()
        if not self._is_updated():
            # before copy, make sure source is updated.
            self.update()
        ret._parsed_resource = self._parsed_resource
        return ret
101961
def copy(self):
        

        copy = self.__class__()
        copy._certs = self._certs[:]
        copy._cert_hashes = self._cert_hashes.copy()
        return copy
643657
def copy(self, key=None):
        
        other = self.__class__(redis=self.redis, key=key)
        other.update(self)

        return other
850277
def copy(self, deep=True):
        
        from copy import copy, deepcopy
        if deep:
            return deepcopy(self)
        else:
            return copy(self)
885072
def copy(self):
        
        s = MemoryData(self.address, self.size, self.sort, pointer_addr=self.pointer_addr, max_size=self.max_size)
        s.content = self.content

        return s
784569
def copy(self):
        ""
        other = _ChainedHashAlgorithm(self._algorithms)
        other._hobj = deepcopy(self._hobj)
        other._fobj = deepcopy(self._fobj)
        return other
568436
def copy(self):
    
    if self._iters:
      a, b = it.tee(self._iters[0])
      self._iters[0] = a
      return Stream(b)
    iter(self)
68642
def clone(self):
        
        obj = self.__class__()
        obj.libs = deepcopy(self.libs)
        return obj
446440
def copy(self, cls=None):
        '''  '''
        cls = cls or BaseResponse
        assert issubclass(cls, BaseResponse)
        copy = cls()
        copy.status = self.status
        copy._headers = dict((k, v[:]) for (k, v) in self._headers.items())
        if self._cookies:
            copy._cookies = SimpleCookie()
            copy._cookies.load(self._cookies.output(header=''))
        return copy
1038103
def copy(self):
        

        copy = MOC(name=self.name, mocid=self.id,
                   origin=self.origin, moctype=self.type)

        copy += self

        return copy
478125
def copy(self, keep_fields=None):
        
        keep_fields = self.fields.keys() or keep_fields
        return self.__class__(OrderedDict([(name, data[:]) for name, data in self.fields.items() if name in keep_fields]))
1098189
def copy(self):
        
        state_copy = State()
        state_copy._state_dict = copy.deepcopy(self._state_dict)
        return state_copy
98749
def copy(self):
        
        dup = type(self)()
        dup._indices = OrderedDict(
            (k, list(v)) for k,v in six.iteritems(self._indices)
        )
        dup._lines = self._lines.copy()
        return dup
1327771
def clone(self):
        
        from copy import copy
        clone = copy(self)
        clone.expr = copy(self.expr)
        clone.factory = False
        return clone
604686
def copy(self):
        '''

        '''
        # Significant performance improvements by skipping alphabet check
        return type(self)(self.seq, self.material, run_checks=False)
805508
def copy(self):
        
        return self.__class__(self.tag, self.data.copy(), self.context.copy())
39171
def clone(self):
        

        p = type(self)(self.id)
        p.hooks = list(self.hooks)
        p.instance = self.instance
        return p