Parameters
        ----------
        copy : boolean, default False
            Whether to copy the blocks
438120
def get_numeric_data(self, copy=False):
        
        self._consolidate_inplace()
        return self.combine([b for b in self.blocks if b.is_numeric], copy)
1315808
def copy(self, selection, smart_selection_adaption=True):
        
        assert isinstance(selection, Selection)
        self.__create_core_and_model_object_copies(selection, smart_selection_adaption)
782522
public void copyFrom(BlockType other) {
        this.isValid = other.isValid;
        this.isTop = other.isTop;
        if (isValid) {
            this.depth = other.depth;
            this.clear();
            this.or(other);
        }
    }
1211085
def copy(data, start=0, stop=None, blen=None, storage=None, create='array',
         **kwargs):
    """"""

    # setup
    storage = _util.get_storage(storage)
    blen = _util.get_blen_array(data, blen)
    if stop is None:
        stop = len(data)
    else:
        stop = min(stop, len(data))
    length = stop - start
    if length < 0:
        raise ValueError('invalid stop/start')

    # copy block-wise
    out = None
    for i in range(start, stop, blen):
        j = min(i+blen, stop)
        block = data[i:j]
        if out is None:
            out = getattr(storage, create)(block, expectedlen=length, **kwargs)
        else:
            out.append(block)

    return out
1211262
def copy(self, deep=True):
        
        result = super().copy(deep=deep)
        result._default_fill_value = self._default_fill_value
        result._default_kind = self._default_kind
        return result
688084
def execute
      options = copy_move_options
      copy_options = @resource.copy_options options

      unless copy_options[:can_copy]
        return :precondition_failed if copy_options[:ancestor_exist]
        return :conflict
      end

      return :locked if copy_options[:locked]

      overwritten = @resource.copy options
      overwritten ? :no_content : :created
    end
1014800
void assignToBlock(BlockId blk) {
		internalLock.writeLock().lock();
		try {
			flush();
			this.blk = blk;
			contents.read(blk);
			pins = 0;
			lastLsn = LogSeqNum.readFromPage(contents, LAST_LSN_OFFSET);
		} finally {
			internalLock.writeLock().unlock();
		}
	}
93552
def copy(srcpath, dstpath, overwrite=True):
    """"""
    # Handle bail conditions.
    if not op.exists(srcpath):
        return False
    if not overwrite:
        if op.isfile(dstpath):
            return False
        if op.isdir(dstpath):
            chkpath = op.join(dstpath, op.basename(srcpath))
            if op.isdir(chkpath) or op.isfile(chkpath):
                return False
    srcpath = op.abspath(srcpath)
    dstpath = op.abspath(dstpath)

    # Handle copying.
    if op.isdir(srcpath):
        dstdir = dstpath
        if op.isfile(dstpath):
            dstdir = op.dirname(dstpath)
        elif op.isdir(dstpath):
            # Make sure srcdir is copied INTO dstdir.
            dstdir = op.join(dstpath, op.basename(srcpath))
        makedirs(dstdir)
        for r,ds,fs in os.walk(srcpath):
            basedir = r.replace(srcpath, "").rstrip(os.sep).strip(os.sep)
            curdir = op.join(dstdir, basedir)
            makedirs(curdir)
            for f in fs:
                if not copy(op.join(r,f), op.join(curdir, f), overwrite=overwrite):
                    return False
    elif op.isfile(srcpath):
        makedirs(dstpath)
        shutil.copy2(srcpath, dstpath)

    return op.exists(dstpath)
186486
def should_copy(column):
    
    if not isinstance(column.type, Serial):
        return True

    if column.nullable:
        return True

    if not column.server_default:
        return True

    # do not create temporary serial values; they will be defaulted on upsert/insert
    return False
857816
def copy(self):
        """"""
        return self.__class__([b.copy() for b in self.blocks],
                tuple(self.pos) if self.pos else None)
604686
def copy(self):
        '''

        '''
        # Significant performance improvements by skipping alphabet check
        return type(self)(self.seq, self.material, run_checks=False)
1328289
void moveBlock()
    {
        int offset = _bufferOffset + _pos - _keepSizeBefore;
        // we need one additional byte, since movePos moves on 1 byte.
        if (offset > 0)
        {
            offset--;
        }

        int numBytes = _bufferOffset + _streamPos - offset;

        // check negative offset ????
        System.arraycopy(_bufferBase, offset, _bufferBase, 0, numBytes);
        _bufferOffset -= offset;
    }
1069438
def copy(self, copy_backends=True, copy_default_backend=True,
             copy_cache=None, copy_history=None):
        
        copied = Circuit(self.n_qubits, self.ops.copy())
        if copy_backends:
            copied._backends = {k: v.copy() for k, v in self._backends.items()}
        if copy_default_backend:
            copied._default_backend = self._default_backend

        # Warn for deprecated options
        if copy_cache is not None:
            warnings.warn("copy_cache is deprecated. Use copy_backends instead.",
                          DeprecationWarning)
        if copy_history is not None:
            warnings.warn("copy_history is deprecated.", DeprecationWarning)

        return copied
1033105
def setBlockCompleted(pieceIndex, blockOffset, bool, clearRequested = :clear_requested)
      bi = blockIndexFromPieceAndOffset(pieceIndex, blockOffset)
      @requestedBlocks.clear bi if clearRequested == :clear_requested
      if bool
        @completeBlocks.set bi
        if allBlocksInPieceCompleted?(pieceIndex)
          yield pieceIndex if block_given?
          @completePieces.set pieceIndex
        end
      else
        @completeBlocks.clear bi
        @completePieces.clear pieceIndex
      end
    end
1193749
public void writeBlock(byte[] block) throws IOException {

        if (block.length != 512) {
            throw new IllegalArgumentException(
                RB.singleton.getString(RB.BAD_BLOCK_WRITE_LEN, block.length));
        }

        write(block, block.length);
    }
1333162
def write(self, block):
        
        self.fileobj.write(block)
        self.status.update(len(block))
620032
def copy_raw_block(self):
        '''
        
        '''
        ctable = []
        r, c = 0, 0
        try:
            for row_index in range(self.start[0], self.end[0]):
                r = row_index
                row = []
                ctable.append(row)
                for column_index in range(self.start[1], self.end[1]):
                    c = column_index
                    row.append(self.table[row_index][column_index])
        except IndexError:
            raise InvalidBlockError('Missing table element at [%d, %d]' % (r, c))
        return ctable