def read()

in odps/tunnel/volumetunnel.py [0:0]

• 70 lines of code
• 24 McCabe index (conditional complexity)

    def read(self, size=None, break_line=False):
        if size is None:
            size = sys.maxsize
        if self._eof:
            return None
        if size == 0:
            return six.binary_type()

        if not self._initialized:
            self._initialized = True
            self._init_buf()

        has_stuff = False

        out_buf = six.BytesIO()
        if self._left_part:
            if break_line:
                # deal with Windows line endings
                if self._left_part[self._left_part_pos] == ord(
                    "\n"
                ) and self._last_line_ending == ord("\r"):
                    self._last_line_ending = None
                    self._left_part_pos += 1

                for idx in irange(self._left_part_pos, len(self._left_part)):
                    if self._left_part[idx] not in (ord("\r"), ord("\n")):
                        continue
                    self._last_line_ending = self._left_part[idx]
                    self._left_part[idx] = ord("\n")
                    ret = self._left_part[self._left_part_pos : idx + 1]
                    self._left_part_pos = idx + 1
                    if self._left_part_pos == len(self._left_part):
                        self._left_part = None
                        self._left_part_pos = 0
                    return bytes(ret)
            if len(self._left_part) - self._left_part_pos >= size:
                ret = self._left_part[self._left_part_pos : self._left_part_pos + size]
                self._left_part_pos += size
                return bytes(ret)
            else:
                out_buf.write(bytes(self._left_part[self._left_part_pos :]))
                self._left_part = None
                self._left_part_pos = 0
                has_stuff = True
        length_left = size - out_buf.tell()
        while length_left > 0:
            buf = self._read_buf()
            if buf is None:
                self._eof = True
                break
            has_stuff = True
            start_pos = 0
            if break_line:
                if buf[0] == ord("\n") and self._last_line_ending == ord("\r"):
                    start_pos = 1
                for idx in irange(start_pos, len(buf)):
                    if buf[idx] not in (ord("\r"), ord("\n")):
                        continue
                    self._last_line_ending = buf[idx]
                    buf[idx] = ord("\n")
                    out_buf.write(bytes(buf[start_pos : idx + 1]))
                    if idx + 1 < len(buf):
                        self._left_part = buf[idx + 1 :]
                        self._left_part_pos = 0
                    return out_buf.getvalue()

            if len(buf) >= length_left:
                out_buf.write(bytes(buf[start_pos : start_pos + length_left]))
                if len(buf) > length_left:
                    self._left_part = buf[start_pos + length_left :]
                    self._left_part_pos = 0
                length_left = 0
            else:
                out_buf.write(bytes(buf[start_pos : start_pos + self._data_size]))
                length_left -= self._data_size
        return out_buf.getvalue() if has_stuff else None