Since I expect few servers support BLOCK mode, I would explicitly send "MODE" command only if self.transmissionmode != S

suggested change: isinstance(what, bytes)

It probably makes sense to raise ValueError if specified mode is not in ("S", "B").

Also, does the RFC say anything about what should happen if you switch back to STREAM mode from BLOCK mode (knowing RFC-959 myself, I imagine not)? Should the dataconn socket be closed?

You should call this also from close() method (important).

Also, "data connection" is a very well established concept in FTP, but 99% of the times applies to STREAMing mode. I would be more explicit and call this method _close_block_dataconn or _close_persistent_dataconn.

Why? Is it because returned data may be < 3 bytes?

I suggest ValueError("Invalid transmission mode %r" % self.transmissionmode)

Since I expect few servers to implement BLOCK mode, I would avoid sending MODE command unless it's really necessary. I would change this to:

if self.transmissionmode != 'S':
     # BLOCK mode only applies to RETR. STOR does not support  it.
     self.voidcmd('MODE S')

You should probably mention that BLOCK is supported for RETR (donwload) only.

Adding (+) chunks of bytes on every iteration is not very efficient. You could use a bytearray instead. Not tested:

        buff = bytearray()
        curr_length = blocklength
        while len(buff) < blocklength:
            chunk = conn.recv(curr_length)
            buff.extend(chunk)
            curr_length -= len(chunk)
        data = bytes(buff)

In order to avoid making this method too complex, perhaps it makes sense to encapsulate this logic in a utility function (again, not tested):

def _read_until(sock, length):
    if length <= 0:
        return b""
    buff = bytearray()
    curr_length = length
    while len(buff) < length:
        chunk = sock.recv(curr_length)
        buff.extend(chunk)
        curr_length -= len(chunk)
    return bytes(buff)

Also, if the server sends us a big number (say size = 1G), we will hog RAM. I wonder if it would make sense to implement an additional, internal buffer, that calls callback function after a certain threshold (e.g. 1M) and empties the internal memory buffer.

transmission_mode?