Reads a dword value from the L{ReadData} stream object.
        
        @rtype: int
        @return: The dword value read from the L{ReadData} stream.
557104
def readDword(self):
        
        dword = unpack(self.endianness + ('L' if not self.signed else 'l'), self.readAt(self.offset,  4))[0]
        self.offset += 4
        return dword
1043358
def _read(self):
        
        if self._dask:
            d = da.from_delayed(
                delayed(read_from_bpch, )(
                    self.filename, self.file_position, self.shape,
                    self.dtype, self.endian, use_mmap=self._mmap
                ),
                self.shape, self.dtype
            )
        else:
            d = read_from_bpch(
                    self.filename, self.file_position, self.shape,
                    self.dtype, self.endian, use_mmap=self._mmap
            )

        return d
1203494
def _read(cls, **kwargs):
        
        pd_obj = pandas.read_csv(**kwargs)
        if isinstance(pd_obj, pandas.DataFrame):
            return cls.from_pandas(pd_obj)
        if isinstance(pd_obj, pandas.io.parsers.TextFileReader):
            # Overwriting the read method should return a ray DataFrame for calls
            # to __next__ and get_chunk
            pd_read = pd_obj.read
            pd_obj.read = lambda *args, **kwargs: cls.from_pandas(
                pd_read(*args, **kwargs)
            )
        return pd_obj
324490
def read(self):
        
        # Read value
        try:
            buf = os.read(self._fd, 8)
        except OSError as e:
            raise LEDError(e.errno, "Reading LED brightness: " + e.strerror)

        # Rewind
        try:
            os.lseek(self._fd, 0, os.SEEK_SET)
        except OSError as e:
            raise LEDError(e.errno, "Rewinding LED brightness: " + e.strerror)

        return int(buf)
53051
protected int readWord(InputStream inputStream) throws IOException {
        byte[] bytes = new byte[2];
        boolean success = inputStream.read(bytes) == 2;
        return !success ? -1 : readWord(bytes, 0);
    }
311063
def read_byte(self):
        
        buf = b''
        if len(self.cookedq) > 0:
            buf = bytes([self.cookedq[0]])
            self.cookedq = self.cookedq[1:]
        else:
            yield from self.process_rawq()
            if not self.eof:
                yield from self.fill_rawq()
                yield from self.process_rawq()
                # There now should be data so lets read again
                buf = yield from self.read_byte()

        return buf
454050
def readQword(self):
        
        qword = unpack(self.endianness + ('Q' if not self.signed else 'b'),  self.readAt(self.offset, 8))[0]
        self.offset += 8
        return qword
1271594
def read(self, n=-1):
        
        if n < -1:
            raise IOError('Cannot read backwards')

        bytes = self._buffer.read(n)

        return bytes
968370
def getDwordAtOffset(self, offset):
        
        return datatypes.DWORD.parse(utils.ReadData(self.getDataAtOffset(offset,  4)))
1065259
def read(self):
        
        if self._output_buffer:
            b, self._output_buffer = (self._output_buffer[0:1],
                                      self._output_buffer[1:])
            return b

        return b''
1233032
def read(self, count):
        

        offset = self.offset
        if self.data:
            avail = len(self.data) - offset
        else:
            avail = 0

        if avail < count:
            raise UnpackException(None, count, avail)

        self.offset = offset + count
        return self.data[offset:self.offset]
490409
def read_some(self):
        
        self.process_rawq()
        while self.cookedq.tell() == 0 and not self.eof:
            self.fill_rawq()
            self.process_rawq()
        buf = self.cookedq.getvalue()
        self.cookedq.seek(0)
        self.cookedq.truncate()
        return buf
1335298
def reader(self):
        
        request_stream = ''
        with self.connect() as request:
            if request.msg != 'OK':
                raise HTTPError
            request_stream = request.read().decode('utf-8')
        return request_stream
100366
def read(self, len):
        
        ret = libxml2mod.xmlParserInputBufferRead(self._o, len)
        return ret
387339
def read(self, n=1):
        
        self.offset += n
        return self.data[self.offset - n:self.offset]
408817
def _read_channel(stream, num, name, ctype, epoch, start, end,
                  scaled=True, series_class=TimeSeries):
    
    data = _get_frdata(stream, num, name, ctype=ctype)
    return read_frdata(data, epoch, start, end,
                       scaled=scaled, series_class=series_class)
1013935
def tell(self):
        
        res = self._stream.tell()
        if len(self._bits) > 0:
            res -= 1
        return res