Code
stringlengths 103
85.9k
| Summary
listlengths 0
94
|
|---|---|
Please provide a description of the function:def _readuint(self, length, start):
if not length:
raise InterpretError("Cannot interpret a zero length bitstring "
"as an integer.")
offset = self._offset
startbyte = (start + offset) // 8
endbyte = (start + offset + length - 1) // 8
b = binascii.hexlify(bytes(self._datastore.getbyteslice(startbyte, endbyte + 1)))
assert b
i = int(b, 16)
final_bits = 8 - ((start + offset + length) % 8)
if final_bits != 8:
i >>= final_bits
i &= (1 << length) - 1
return i
|
[
"Read bits and interpret as an unsigned int."
] |
Please provide a description of the function:def _setint(self, int_, length=None):
# If no length given, and we've previously been given a length, use it.
if length is None and hasattr(self, 'len') and self.len != 0:
length = self.len
if length is None or length == 0:
raise CreationError("A non-zero length must be specified with an int initialiser.")
if int_ >= (1 << (length - 1)) or int_ < -(1 << (length - 1)):
raise CreationError("{0} is too large a signed integer for a bitstring of length {1}. "
"The allowed range is [{2}, {3}].", int_, length, -(1 << (length - 1)),
(1 << (length - 1)) - 1)
if int_ >= 0:
self._setuint(int_, length)
return
# TODO: We should decide whether to just use the _setuint, or to do the bit flipping,
# based upon which will be quicker. If the -ive number is less than half the maximum
# possible then it's probably quicker to do the bit flipping...
# Do the 2's complement thing. Add one, set to minus number, then flip bits.
int_ += 1
self._setuint(-int_, length)
self._invert_all()
|
[
"Reset the bitstring to have given signed int interpretation."
] |
Please provide a description of the function:def _readint(self, length, start):
ui = self._readuint(length, start)
if not ui >> (length - 1):
# Top bit not set, number is positive
return ui
# Top bit is set, so number is negative
tmp = (~(ui - 1)) & ((1 << length) - 1)
return -tmp
|
[
"Read bits and interpret as a signed int"
] |
Please provide a description of the function:def _setuintbe(self, uintbe, length=None):
if length is not None and length % 8 != 0:
raise CreationError("Big-endian integers must be whole-byte. "
"Length = {0} bits.", length)
self._setuint(uintbe, length)
|
[
"Set the bitstring to a big-endian unsigned int interpretation."
] |
Please provide a description of the function:def _readuintbe(self, length, start):
if length % 8:
raise InterpretError("Big-endian integers must be whole-byte. "
"Length = {0} bits.", length)
return self._readuint(length, start)
|
[
"Read bits and interpret as a big-endian unsigned int."
] |
Please provide a description of the function:def _setintbe(self, intbe, length=None):
if length is not None and length % 8 != 0:
raise CreationError("Big-endian integers must be whole-byte. "
"Length = {0} bits.", length)
self._setint(intbe, length)
|
[
"Set bitstring to a big-endian signed int interpretation."
] |
Please provide a description of the function:def _readintbe(self, length, start):
if length % 8:
raise InterpretError("Big-endian integers must be whole-byte. "
"Length = {0} bits.", length)
return self._readint(length, start)
|
[
"Read bits and interpret as a big-endian signed int."
] |
Please provide a description of the function:def _readuintle(self, length, start):
if length % 8:
raise InterpretError("Little-endian integers must be whole-byte. "
"Length = {0} bits.", length)
assert start + length <= self.len
absolute_pos = start + self._offset
startbyte, offset = divmod(absolute_pos, 8)
val = 0
if not offset:
endbyte = (absolute_pos + length - 1) // 8
chunksize = 4 # for 'L' format
while endbyte - chunksize + 1 >= startbyte:
val <<= 8 * chunksize
val += struct.unpack('<L', bytes(self._datastore.getbyteslice(endbyte + 1 - chunksize, endbyte + 1)))[0]
endbyte -= chunksize
for b in xrange(endbyte, startbyte - 1, -1):
val <<= 8
val += self._datastore.getbyte(b)
else:
data = self._slice(start, start + length)
assert data.len % 8 == 0
data._reversebytes(0, self.len)
for b in bytearray(data.bytes):
val <<= 8
val += b
return val
|
[
"Read bits and interpret as a little-endian unsigned int."
] |
Please provide a description of the function:def _readintle(self, length, start):
ui = self._readuintle(length, start)
if not ui >> (length - 1):
# Top bit not set, number is positive
return ui
# Top bit is set, so number is negative
tmp = (~(ui - 1)) & ((1 << length) - 1)
return -tmp
|
[
"Read bits and interpret as a little-endian signed int."
] |
Please provide a description of the function:def _readfloat(self, length, start):
if not (start + self._offset) % 8:
startbyte = (start + self._offset) // 8
if length == 32:
f, = struct.unpack('>f', bytes(self._datastore.getbyteslice(startbyte, startbyte + 4)))
elif length == 64:
f, = struct.unpack('>d', bytes(self._datastore.getbyteslice(startbyte, startbyte + 8)))
else:
if length == 32:
f, = struct.unpack('>f', self._readbytes(32, start))
elif length == 64:
f, = struct.unpack('>d', self._readbytes(64, start))
try:
return f
except NameError:
raise InterpretError("floats can only be 32 or 64 bits long, not {0} bits", length)
|
[
"Read bits and interpret as a float."
] |
Please provide a description of the function:def _readfloatle(self, length, start):
startbyte, offset = divmod(start + self._offset, 8)
if not offset:
if length == 32:
f, = struct.unpack('<f', bytes(self._datastore.getbyteslice(startbyte, startbyte + 4)))
elif length == 64:
f, = struct.unpack('<d', bytes(self._datastore.getbyteslice(startbyte, startbyte + 8)))
else:
if length == 32:
f, = struct.unpack('<f', self._readbytes(32, start))
elif length == 64:
f, = struct.unpack('<d', self._readbytes(64, start))
try:
return f
except NameError:
raise InterpretError("floats can only be 32 or 64 bits long, "
"not {0} bits", length)
|
[
"Read bits and interpret as a little-endian float."
] |
Please provide a description of the function:def _setue(self, i):
if i < 0:
raise CreationError("Cannot use negative initialiser for unsigned "
"exponential-Golomb.")
if not i:
self._setbin_unsafe('1')
return
tmp = i + 1
leadingzeros = -1
while tmp > 0:
tmp >>= 1
leadingzeros += 1
remainingpart = i + 1 - (1 << leadingzeros)
binstring = '0' * leadingzeros + '1' + Bits(uint=remainingpart,
length=leadingzeros).bin
self._setbin_unsafe(binstring)
|
[
"Initialise bitstring with unsigned exponential-Golomb code for integer i.\n\n Raises CreationError if i < 0.\n\n "
] |
Please provide a description of the function:def _readue(self, pos):
oldpos = pos
try:
while not self[pos]:
pos += 1
except IndexError:
raise ReadError("Read off end of bitstring trying to read code.")
leadingzeros = pos - oldpos
codenum = (1 << leadingzeros) - 1
if leadingzeros > 0:
if pos + leadingzeros + 1 > self.len:
raise ReadError("Read off end of bitstring trying to read code.")
codenum += self._readuint(leadingzeros, pos + 1)
pos += leadingzeros + 1
else:
assert codenum == 0
pos += 1
return codenum, pos
|
[
"Return interpretation of next bits as unsigned exponential-Golomb code.\n\n Raises ReadError if the end of the bitstring is encountered while\n reading the code.\n\n "
] |
Please provide a description of the function:def _getue(self):
try:
value, newpos = self._readue(0)
if value is None or newpos != self.len:
raise ReadError
except ReadError:
raise InterpretError("Bitstring is not a single exponential-Golomb code.")
return value
|
[
"Return data as unsigned exponential-Golomb code.\n\n Raises InterpretError if bitstring is not a single exponential-Golomb code.\n\n "
] |
Please provide a description of the function:def _setse(self, i):
if i > 0:
u = (i * 2) - 1
else:
u = -2 * i
self._setue(u)
|
[
"Initialise bitstring with signed exponential-Golomb code for integer i."
] |
Please provide a description of the function:def _getse(self):
try:
value, newpos = self._readse(0)
if value is None or newpos != self.len:
raise ReadError
except ReadError:
raise InterpretError("Bitstring is not a single exponential-Golomb code.")
return value
|
[
"Return data as signed exponential-Golomb code.\n\n Raises InterpretError if bitstring is not a single exponential-Golomb code.\n\n "
] |
Please provide a description of the function:def _readse(self, pos):
codenum, pos = self._readue(pos)
m = (codenum + 1) // 2
if not codenum % 2:
return -m, pos
else:
return m, pos
|
[
"Return interpretation of next bits as a signed exponential-Golomb code.\n\n Advances position to after the read code.\n\n Raises ReadError if the end of the bitstring is encountered while\n reading the code.\n\n "
] |
Please provide a description of the function:def _setuie(self, i):
if i < 0:
raise CreationError("Cannot use negative initialiser for unsigned "
"interleaved exponential-Golomb.")
self._setbin_unsafe('1' if i == 0 else '0' + '0'.join(bin(i + 1)[3:]) + '1')
|
[
"Initialise bitstring with unsigned interleaved exponential-Golomb code for integer i.\n\n Raises CreationError if i < 0.\n\n "
] |
Please provide a description of the function:def _getuie(self):
try:
value, newpos = self._readuie(0)
if value is None or newpos != self.len:
raise ReadError
except ReadError:
raise InterpretError("Bitstring is not a single interleaved exponential-Golomb code.")
return value
|
[
"Return data as unsigned interleaved exponential-Golomb code.\n\n Raises InterpretError if bitstring is not a single exponential-Golomb code.\n\n "
] |
Please provide a description of the function:def _setsie(self, i):
if not i:
self._setbin_unsafe('1')
else:
self._setuie(abs(i))
self._append(Bits([i < 0]))
|
[
"Initialise bitstring with signed interleaved exponential-Golomb code for integer i."
] |
Please provide a description of the function:def _getsie(self):
try:
value, newpos = self._readsie(0)
if value is None or newpos != self.len:
raise ReadError
except ReadError:
raise InterpretError("Bitstring is not a single interleaved exponential-Golomb code.")
return value
|
[
"Return data as signed interleaved exponential-Golomb code.\n\n Raises InterpretError if bitstring is not a single exponential-Golomb code.\n\n "
] |
Please provide a description of the function:def _readsie(self, pos):
codenum, pos = self._readuie(pos)
if not codenum:
return 0, pos
try:
if self[pos]:
return -codenum, pos + 1
else:
return codenum, pos + 1
except IndexError:
raise ReadError("Read off end of bitstring trying to read code.")
|
[
"Return interpretation of next bits as a signed interleaved exponential-Golomb code.\n\n Advances position to after the read code.\n\n Raises ReadError if the end of the bitstring is encountered while\n reading the code.\n\n "
] |
Please provide a description of the function:def _setbin_safe(self, binstring):
binstring = tidy_input_string(binstring)
# remove any 0b if present
binstring = binstring.replace('0b', '')
self._setbin_unsafe(binstring)
|
[
"Reset the bitstring to the value given in binstring."
] |
Please provide a description of the function:def _setbin_unsafe(self, binstring):
length = len(binstring)
# pad with zeros up to byte boundary if needed
boundary = ((length + 7) // 8) * 8
padded_binstring = binstring + '0' * (boundary - length)\
if len(binstring) < boundary else binstring
try:
bytelist = [int(padded_binstring[x:x + 8], 2)
for x in xrange(0, len(padded_binstring), 8)]
except ValueError:
raise CreationError("Invalid character in bin initialiser {0}.", binstring)
self._setbytes_unsafe(bytearray(bytelist), length, 0)
|
[
"Same as _setbin_safe, but input isn't sanity checked. binstring mustn't start with '0b'."
] |
Please provide a description of the function:def _readbin(self, length, start):
if not length:
return ''
# Get the byte slice containing our bit slice
startbyte, startoffset = divmod(start + self._offset, 8)
endbyte = (start + self._offset + length - 1) // 8
b = self._datastore.getbyteslice(startbyte, endbyte + 1)
# Convert to a string of '0' and '1's (via a hex string an and int!)
try:
c = "{:0{}b}".format(int(binascii.hexlify(b), 16), 8*len(b))
except TypeError:
# Hack to get Python 2.6 working
c = "{0:0{1}b}".format(int(binascii.hexlify(str(b)), 16), 8*len(b))
# Finally chop off any extra bits.
return c[startoffset:startoffset + length]
|
[
"Read bits and interpret as a binary string."
] |
Please provide a description of the function:def _setoct(self, octstring):
octstring = tidy_input_string(octstring)
# remove any 0o if present
octstring = octstring.replace('0o', '')
binlist = []
for i in octstring:
try:
if not 0 <= int(i) < 8:
raise ValueError
binlist.append(OCT_TO_BITS[int(i)])
except ValueError:
raise CreationError("Invalid symbol '{0}' in oct initialiser.", i)
self._setbin_unsafe(''.join(binlist))
|
[
"Reset the bitstring to have the value given in octstring."
] |
Please provide a description of the function:def _readoct(self, length, start):
if length % 3:
raise InterpretError("Cannot convert to octal unambiguously - "
"not multiple of 3 bits.")
if not length:
return ''
# Get main octal bit by converting from int.
# Strip starting 0 or 0o depending on Python version.
end = oct(self._readuint(length, start))[LEADING_OCT_CHARS:]
if end.endswith('L'):
end = end[:-1]
middle = '0' * (length // 3 - len(end))
return middle + end
|
[
"Read bits and interpret as an octal string."
] |
Please provide a description of the function:def _sethex(self, hexstring):
hexstring = tidy_input_string(hexstring)
# remove any 0x if present
hexstring = hexstring.replace('0x', '')
length = len(hexstring)
if length % 2:
hexstring += '0'
try:
try:
data = bytearray.fromhex(hexstring)
except TypeError:
# Python 2.6 needs a unicode string (a bug). 2.7 and 3.x work fine.
data = bytearray.fromhex(unicode(hexstring))
except ValueError:
raise CreationError("Invalid symbol in hex initialiser.")
self._setbytes_unsafe(data, length * 4, 0)
|
[
"Reset the bitstring to have the value given in hexstring."
] |
Please provide a description of the function:def _readhex(self, length, start):
if length % 4:
raise InterpretError("Cannot convert to hex unambiguously - "
"not multiple of 4 bits.")
if not length:
return ''
s = self._slice(start, start + length).tobytes()
try:
s = s.hex() # Available in Python 3.5
except AttributeError:
# This monstrosity is the only thing I could get to work for both 2.6 and 3.1.
# TODO: Is utf-8 really what we mean here?
s = str(binascii.hexlify(s).decode('utf-8'))
# If there's one nibble too many then cut it off
return s[:-1] if (length // 4) % 2 else s
|
[
"Read bits and interpret as a hex string."
] |
Please provide a description of the function:def _ensureinmemory(self):
self._setbytes_unsafe(self._datastore.getbyteslice(0, self._datastore.bytelength),
self.len, self._offset)
|
[
"Ensure the data is held in memory, not in a file."
] |
Please provide a description of the function:def _converttobitstring(cls, bs, offset=0, cache={}):
if isinstance(bs, Bits):
return bs
try:
return cache[(bs, offset)]
except KeyError:
if isinstance(bs, basestring):
b = cls()
try:
_, tokens = tokenparser(bs)
except ValueError as e:
raise CreationError(*e.args)
if tokens:
b._append(Bits._init_with_token(*tokens[0]))
b._datastore = offsetcopy(b._datastore, offset)
for token in tokens[1:]:
b._append(Bits._init_with_token(*token))
assert b._assertsanity()
assert b.len == 0 or b._offset == offset
if len(cache) < CACHE_SIZE:
cache[(bs, offset)] = b
return b
except TypeError:
# Unhashable type
pass
return cls(bs)
|
[
"Convert bs to a bitstring and return it.\n\n offset gives the suggested bit offset of first significant\n bit, to optimise append etc.\n\n "
] |
Please provide a description of the function:def _copy(self):
s_copy = self.__class__()
s_copy._setbytes_unsafe(self._datastore.getbyteslice(0, self._datastore.bytelength),
self.len, self._offset)
return s_copy
|
[
"Create and return a new copy of the Bits (always in memory)."
] |
Please provide a description of the function:def _slice(self, start, end):
if end == start:
return self.__class__()
offset = self._offset
startbyte, newoffset = divmod(start + offset, 8)
endbyte = (end + offset - 1) // 8
bs = self.__class__()
bs._setbytes_unsafe(self._datastore.getbyteslice(startbyte, endbyte + 1), end - start, newoffset)
return bs
|
[
"Used internally to get a slice, without error checking."
] |
Please provide a description of the function:def _readtoken(self, name, pos, length):
if length is not None and int(length) > self.length - pos:
raise ReadError("Reading off the end of the data. "
"Tried to read {0} bits when only {1} available.".format(int(length), self.length - pos))
try:
val = name_to_read[name](self, length, pos)
return val, pos + length
except KeyError:
if name == 'pad':
return None, pos + length
raise ValueError("Can't parse token {0}:{1}".format(name, length))
except TypeError:
# This is for the 'ue', 'se' and 'bool' tokens. They will also return the new pos.
return name_to_read[name](self, pos)
|
[
"Reads a token from the bitstring and returns the result."
] |
Please provide a description of the function:def _reverse(self):
# Reverse the contents of each byte
n = [BYTE_REVERSAL_DICT[b] for b in self._datastore.rawbytes]
# Then reverse the order of the bytes
n.reverse()
# The new offset is the number of bits that were unused at the end.
newoffset = 8 - (self._offset + self.len) % 8
if newoffset == 8:
newoffset = 0
self._setbytes_unsafe(bytearray().join(n), self.length, newoffset)
|
[
"Reverse all bits in-place."
] |
Please provide a description of the function:def _truncateend(self, bits):
assert 0 <= bits <= self.len
if not bits:
return
if bits == self.len:
self._clear()
return
newlength_in_bytes = (self._offset + self.len - bits + 7) // 8
self._setbytes_unsafe(self._datastore.getbyteslice(0, newlength_in_bytes), self.len - bits,
self._offset)
assert self._assertsanity()
|
[
"Truncate bits from the end of the bitstring."
] |
Please provide a description of the function:def _insert(self, bs, pos):
assert 0 <= pos <= self.len
if pos > self.len // 2:
# Inserting nearer end, so cut off end.
end = self._slice(pos, self.len)
self._truncateend(self.len - pos)
self._append(bs)
self._append(end)
else:
# Inserting nearer start, so cut off start.
start = self._slice(0, pos)
self._truncatestart(pos)
self._prepend(bs)
self._prepend(start)
try:
self._pos = pos + bs.len
except AttributeError:
pass
assert self._assertsanity()
|
[
"Insert bs at pos."
] |
Please provide a description of the function:def _overwrite(self, bs, pos):
assert 0 <= pos < self.len
if bs is self:
# Just overwriting with self, so do nothing.
assert pos == 0
return
firstbytepos = (self._offset + pos) // 8
lastbytepos = (self._offset + pos + bs.len - 1) // 8
bytepos, bitoffset = divmod(self._offset + pos, 8)
if firstbytepos == lastbytepos:
mask = ((1 << bs.len) - 1) << (8 - bs.len - bitoffset)
self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) & (~mask))
d = offsetcopy(bs._datastore, bitoffset)
self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) | (d.getbyte(0) & mask))
else:
# Do first byte
mask = (1 << (8 - bitoffset)) - 1
self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) & (~mask))
d = offsetcopy(bs._datastore, bitoffset)
self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) | (d.getbyte(0) & mask))
# Now do all the full bytes
self._datastore.setbyteslice(firstbytepos + 1, lastbytepos, d.getbyteslice(1, lastbytepos - firstbytepos))
# and finally the last byte
bitsleft = (self._offset + pos + bs.len) % 8
if not bitsleft:
bitsleft = 8
mask = (1 << (8 - bitsleft)) - 1
self._datastore.setbyte(lastbytepos, self._datastore.getbyte(lastbytepos) & mask)
self._datastore.setbyte(lastbytepos,
self._datastore.getbyte(lastbytepos) | (d.getbyte(d.bytelength - 1) & ~mask))
assert self._assertsanity()
|
[
"Overwrite with bs at pos."
] |
Please provide a description of the function:def _delete(self, bits, pos):
assert 0 <= pos <= self.len
assert pos + bits <= self.len
if not pos:
# Cutting bits off at the start.
self._truncatestart(bits)
return
if pos + bits == self.len:
# Cutting bits off at the end.
self._truncateend(bits)
return
if pos > self.len - pos - bits:
# More bits before cut point than after it, so do bit shifting
# on the final bits.
end = self._slice(pos + bits, self.len)
assert self.len - pos > 0
self._truncateend(self.len - pos)
self._append(end)
return
# More bits after the cut point than before it.
start = self._slice(0, pos)
self._truncatestart(pos + bits)
self._prepend(start)
return
|
[
"Delete bits at pos."
] |
Please provide a description of the function:def _reversebytes(self, start, end):
# Make the start occur on a byte boundary
# TODO: We could be cleverer here to avoid changing the offset.
newoffset = 8 - (start % 8)
if newoffset == 8:
newoffset = 0
self._datastore = offsetcopy(self._datastore, newoffset)
# Now just reverse the byte data
toreverse = bytearray(self._datastore.getbyteslice((newoffset + start) // 8, (newoffset + end) // 8))
toreverse.reverse()
self._datastore.setbyteslice((newoffset + start) // 8, (newoffset + end) // 8, toreverse)
|
[
"Reverse bytes in-place."
] |
Please provide a description of the function:def _set(self, pos):
assert 0 <= pos < self.len
self._datastore.setbit(pos)
|
[
"Set bit at pos to 1."
] |
Please provide a description of the function:def _unset(self, pos):
assert 0 <= pos < self.len
self._datastore.unsetbit(pos)
|
[
"Set bit at pos to 0."
] |
Please provide a description of the function:def _invert(self, pos):
assert 0 <= pos < self.len
self._datastore.invertbit(pos)
|
[
"Flip bit at pos 1<->0."
] |
Please provide a description of the function:def _invert_all(self):
set = self._datastore.setbyte
get = self._datastore.getbyte
for p in xrange(self._datastore.byteoffset, self._datastore.byteoffset + self._datastore.bytelength):
set(p, 256 + ~get(p))
|
[
"Invert every bit."
] |
Please provide a description of the function:def _ilshift(self, n):
assert 0 < n <= self.len
self._append(Bits(n))
self._truncatestart(n)
return self
|
[
"Shift bits by n to the left in place. Return self."
] |
Please provide a description of the function:def _irshift(self, n):
assert 0 < n <= self.len
self._prepend(Bits(n))
self._truncateend(n)
return self
|
[
"Shift bits by n to the right in place. Return self."
] |
Please provide a description of the function:def _imul(self, n):
assert n >= 0
if not n:
self._clear()
return self
m = 1
old_len = self.len
while m * 2 < n:
self._append(self)
m *= 2
self._append(self[0:(n - m) * old_len])
return self
|
[
"Concatenate n copies of self in place. Return self."
] |
Please provide a description of the function:def _inplace_logical_helper(self, bs, f):
# Give the two bitstrings the same offset (modulo 8)
self_byteoffset, self_bitoffset = divmod(self._offset, 8)
bs_byteoffset, bs_bitoffset = divmod(bs._offset, 8)
if bs_bitoffset != self_bitoffset:
if not self_bitoffset:
bs._datastore = offsetcopy(bs._datastore, 0)
else:
self._datastore = offsetcopy(self._datastore, bs_bitoffset)
a = self._datastore.rawbytes
b = bs._datastore.rawbytes
for i in xrange(len(a)):
a[i] = f(a[i + self_byteoffset], b[i + bs_byteoffset])
return self
|
[
"Helper function containing most of the __ior__, __iand__, __ixor__ code."
] |
Please provide a description of the function:def _validate_slice(self, start, end):
if start is None:
start = 0
elif start < 0:
start += self.len
if end is None:
end = self.len
elif end < 0:
end += self.len
if not 0 <= end <= self.len:
raise ValueError("end is not a valid position in the bitstring.")
if not 0 <= start <= self.len:
raise ValueError("start is not a valid position in the bitstring.")
if end < start:
raise ValueError("end must not be less than start.")
return start, end
|
[
"Validate start and end and return them as positive bit positions."
] |
Please provide a description of the function:def _findbytes(self, bytes_, start, end, bytealigned):
assert self._datastore.offset == 0
assert bytealigned is True
# Extract data bytes from bitstring to be found.
bytepos = (start + 7) // 8
found = False
p = bytepos
finalpos = end // 8
increment = max(1024, len(bytes_) * 10)
buffersize = increment + len(bytes_)
while p < finalpos:
# Read in file or from memory in overlapping chunks and search the chunks.
buf = bytearray(self._datastore.getbyteslice(p, min(p + buffersize, finalpos)))
pos = buf.find(bytes_)
if pos != -1:
found = True
p += pos
break
p += increment
if not found:
return ()
return (p * 8,)
|
[
"Quicker version of find when everything's whole byte\n and byte aligned.\n\n "
] |
Please provide a description of the function:def _findregex(self, reg_ex, start, end, bytealigned):
p = start
length = len(reg_ex.pattern)
# We grab overlapping chunks of the binary representation and
# do an ordinary string search within that.
increment = max(4096, length * 10)
buffersize = increment + length
while p < end:
buf = self._readbin(min(buffersize, end - p), p)
# Test using regular expressions...
m = reg_ex.search(buf)
if m:
pos = m.start()
# pos = buf.find(targetbin)
# if pos != -1:
# if bytealigned then we only accept byte aligned positions.
if not bytealigned or (p + pos) % 8 == 0:
return (p + pos,)
if bytealigned:
# Advance to just beyond the non-byte-aligned match and try again...
p += pos + 1
continue
p += increment
# Not found, return empty tuple
return ()
|
[
"Find first occurrence of a compiled regular expression.\n\n Note that this doesn't support arbitrary regexes, in particular they\n must match a known length.\n\n "
] |
Please provide a description of the function:def find(self, bs, start=None, end=None, bytealigned=None):
bs = Bits(bs)
if not bs.len:
raise ValueError("Cannot find an empty bitstring.")
start, end = self._validate_slice(start, end)
if bytealigned is None:
bytealigned = globals()['bytealigned']
if bytealigned and not bs.len % 8 and not self._datastore.offset:
p = self._findbytes(bs.bytes, start, end, bytealigned)
else:
p = self._findregex(re.compile(bs._getbin()), start, end, bytealigned)
# If called from a class that has a pos, set it
try:
self._pos = p[0]
except (AttributeError, IndexError):
pass
return p
|
[
"Find first occurrence of substring bs.\n\n Returns a single item tuple with the bit position if found, or an\n empty tuple if not found. The bit position (pos property) will\n also be set to the start of the substring if it is found.\n\n bs -- The bitstring to find.\n start -- The bit position to start the search. Defaults to 0.\n end -- The bit position one past the last bit to search.\n Defaults to self.len.\n bytealigned -- If True the bitstring will only be\n found on byte boundaries.\n\n Raises ValueError if bs is empty, if start < 0, if end > self.len or\n if end < start.\n\n >>> BitArray('0xc3e').find('0b1111')\n (6,)\n\n "
] |
Please provide a description of the function:def findall(self, bs, start=None, end=None, count=None, bytealigned=None):
if count is not None and count < 0:
raise ValueError("In findall, count must be >= 0.")
bs = Bits(bs)
start, end = self._validate_slice(start, end)
if bytealigned is None:
bytealigned = globals()['bytealigned']
c = 0
if bytealigned and not bs.len % 8 and not self._datastore.offset:
# Use the quick find method
f = self._findbytes
x = bs._getbytes()
else:
f = self._findregex
x = re.compile(bs._getbin())
while True:
p = f(x, start, end, bytealigned)
if not p:
break
if count is not None and c >= count:
return
c += 1
try:
self._pos = p[0]
except AttributeError:
pass
yield p[0]
if bytealigned:
start = p[0] + 8
else:
start = p[0] + 1
if start >= end:
break
return
|
[
"Find all occurrences of bs. Return generator of bit positions.\n\n bs -- The bitstring to find.\n start -- The bit position to start the search. Defaults to 0.\n end -- The bit position one past the last bit to search.\n Defaults to self.len.\n count -- The maximum number of occurrences to find.\n bytealigned -- If True the bitstring will only be found on\n byte boundaries.\n\n Raises ValueError if bs is empty, if start < 0, if end > self.len or\n if end < start.\n\n Note that all occurrences of bs are found, even if they overlap.\n\n "
] |
Please provide a description of the function:def rfind(self, bs, start=None, end=None, bytealigned=None):
bs = Bits(bs)
start, end = self._validate_slice(start, end)
if bytealigned is None:
bytealigned = globals()['bytealigned']
if not bs.len:
raise ValueError("Cannot find an empty bitstring.")
# Search chunks starting near the end and then moving back
# until we find bs.
increment = max(8192, bs.len * 80)
buffersize = min(increment + bs.len, end - start)
pos = max(start, end - buffersize)
while True:
found = list(self.findall(bs, start=pos, end=pos + buffersize,
bytealigned=bytealigned))
if not found:
if pos == start:
return ()
pos = max(start, pos - increment)
continue
return (found[-1],)
|
[
"Find final occurrence of substring bs.\n\n Returns a single item tuple with the bit position if found, or an\n empty tuple if not found. The bit position (pos property) will\n also be set to the start of the substring if it is found.\n\n bs -- The bitstring to find.\n start -- The bit position to end the reverse search. Defaults to 0.\n end -- The bit position one past the first bit to reverse search.\n Defaults to self.len.\n bytealigned -- If True the bitstring will only be found on byte\n boundaries.\n\n Raises ValueError if bs is empty, if start < 0, if end > self.len or\n if end < start.\n\n "
] |
Please provide a description of the function:def cut(self, bits, start=None, end=None, count=None):
start, end = self._validate_slice(start, end)
if count is not None and count < 0:
raise ValueError("Cannot cut - count must be >= 0.")
if bits <= 0:
raise ValueError("Cannot cut - bits must be >= 0.")
c = 0
while count is None or c < count:
c += 1
nextchunk = self._slice(start, min(start + bits, end))
if nextchunk.len != bits:
return
assert nextchunk._assertsanity()
yield nextchunk
start += bits
return
|
[
"Return bitstring generator by cutting into bits sized chunks.\n\n bits -- The size in bits of the bitstring chunks to generate.\n start -- The bit position to start the first cut. Defaults to 0.\n end -- The bit position one past the last bit to use in the cut.\n Defaults to self.len.\n count -- If specified then at most count items are generated.\n Default is to cut as many times as possible.\n\n "
] |
Please provide a description of the function:def split(self, delimiter, start=None, end=None, count=None,
bytealigned=None):
delimiter = Bits(delimiter)
if not delimiter.len:
raise ValueError("split delimiter cannot be empty.")
start, end = self._validate_slice(start, end)
if bytealigned is None:
bytealigned = globals()['bytealigned']
if count is not None and count < 0:
raise ValueError("Cannot split - count must be >= 0.")
if count == 0:
return
if bytealigned and not delimiter.len % 8 and not self._datastore.offset:
# Use the quick find method
f = self._findbytes
x = delimiter._getbytes()
else:
f = self._findregex
x = re.compile(delimiter._getbin())
found = f(x, start, end, bytealigned)
if not found:
# Initial bits are the whole bitstring being searched
yield self._slice(start, end)
return
# yield the bytes before the first occurrence of the delimiter, even if empty
yield self._slice(start, found[0])
startpos = pos = found[0]
c = 1
while count is None or c < count:
pos += delimiter.len
found = f(x, pos, end, bytealigned)
if not found:
# No more occurrences, so return the rest of the bitstring
yield self._slice(startpos, end)
return
c += 1
yield self._slice(startpos, found[0])
startpos = pos = found[0]
# Have generated count bitstrings, so time to quit.
return
|
[
"Return bitstring generator by splittling using a delimiter.\n\n The first item returned is the initial bitstring before the delimiter,\n which may be an empty bitstring.\n\n delimiter -- The bitstring used as the divider.\n start -- The bit position to start the split. Defaults to 0.\n end -- The bit position one past the last bit to use in the split.\n Defaults to self.len.\n count -- If specified then at most count items are generated.\n Default is to split as many times as possible.\n bytealigned -- If True splits will only occur on byte boundaries.\n\n Raises ValueError if the delimiter is empty.\n\n "
] |
Please provide a description of the function:def join(self, sequence):
s = self.__class__()
i = iter(sequence)
try:
s._append(Bits(next(i)))
while True:
n = next(i)
s._append(self)
s._append(Bits(n))
except StopIteration:
pass
return s
|
[
"Return concatenation of bitstrings joined by self.\n\n sequence -- A sequence of bitstrings.\n\n "
] |
Please provide a description of the function:def tobytes(self):
d = offsetcopy(self._datastore, 0).rawbytes
# Need to ensure that unused bits at end are set to zero
unusedbits = 8 - self.len % 8
if unusedbits != 8:
d[-1] &= (0xff << unusedbits)
return bytes(d)
|
[
"Return the bitstring as bytes, padding with zero bits if needed.\n\n Up to seven zero bits will be added at the end to byte align.\n\n "
] |
Please provide a description of the function:def tofile(self, f):
# If the bitstring is file based then we don't want to read it all
# in to memory.
chunksize = 1024 * 1024 # 1 MB chunks
if not self._offset:
a = 0
bytelen = self._datastore.bytelength
p = self._datastore.getbyteslice(a, min(a + chunksize, bytelen - 1))
while len(p) == chunksize:
f.write(p)
a += chunksize
p = self._datastore.getbyteslice(a, min(a + chunksize, bytelen - 1))
f.write(p)
# Now the final byte, ensuring that unused bits at end are set to 0.
bits_in_final_byte = self.len % 8
if not bits_in_final_byte:
bits_in_final_byte = 8
f.write(self[-bits_in_final_byte:].tobytes())
else:
# Really quite inefficient...
a = 0
b = a + chunksize * 8
while b <= self.len:
f.write(self._slice(a, b)._getbytes())
a += chunksize * 8
b += chunksize * 8
if a != self.len:
f.write(self._slice(a, self.len).tobytes())
|
[
"Write the bitstring to a file object, padding with zero bits if needed.\n\n Up to seven zero bits will be added at the end to byte align.\n\n "
] |
Please provide a description of the function:def startswith(self, prefix, start=None, end=None):
prefix = Bits(prefix)
start, end = self._validate_slice(start, end)
if end < start + prefix.len:
return False
end = start + prefix.len
return self._slice(start, end) == prefix
|
[
"Return whether the current bitstring starts with prefix.\n\n prefix -- The bitstring to search for.\n start -- The bit position to start from. Defaults to 0.\n end -- The bit position to end at. Defaults to self.len.\n\n "
] |
Please provide a description of the function:def endswith(self, suffix, start=None, end=None):
suffix = Bits(suffix)
start, end = self._validate_slice(start, end)
if start + suffix.len > end:
return False
start = end - suffix.len
return self._slice(start, end) == suffix
|
[
"Return whether the current bitstring ends with suffix.\n\n suffix -- The bitstring to search for.\n start -- The bit position to start from. Defaults to 0.\n end -- The bit position to end at. Defaults to self.len.\n\n "
] |
Please provide a description of the function:def all(self, value, pos=None):
value = bool(value)
length = self.len
if pos is None:
pos = xrange(self.len)
for p in pos:
if p < 0:
p += length
if not 0 <= p < length:
raise IndexError("Bit position {0} out of range.".format(p))
if not self._datastore.getbit(p) is value:
return False
return True
|
[
"Return True if one or many bits are all set to value.\n\n value -- If value is True then checks for bits set to 1, otherwise\n checks for bits set to 0.\n pos -- An iterable of bit positions. Negative numbers are treated in\n the same way as slice indices. Defaults to the whole bitstring.\n\n "
] |
Please provide a description of the function:def count(self, value):
if not self.len:
return 0
# count the number of 1s (from which it's easy to work out the 0s).
# Don't count the final byte yet.
count = sum(BIT_COUNT[self._datastore.getbyte(i)] for i in xrange(self._datastore.bytelength - 1))
# adjust for bits at start that aren't part of the bitstring
if self._offset:
count -= BIT_COUNT[self._datastore.getbyte(0) >> (8 - self._offset)]
# and count the last 1 - 8 bits at the end.
endbits = self._datastore.bytelength * 8 - (self._offset + self.len)
count += BIT_COUNT[self._datastore.getbyte(self._datastore.bytelength - 1) >> endbits]
return count if value else self.len - count
|
[
"Return count of total number of either zero or one bits.\n\n value -- If True then bits set to 1 are counted, otherwise bits set\n to 0 are counted.\n\n >>> Bits('0xef').count(1)\n 7\n\n "
] |
Please provide a description of the function:def replace(self, old, new, start=None, end=None, count=None,
bytealigned=None):
old = Bits(old)
new = Bits(new)
if not old.len:
raise ValueError("Empty bitstring cannot be replaced.")
start, end = self._validate_slice(start, end)
if bytealigned is None:
bytealigned = globals()['bytealigned']
# Adjust count for use in split()
if count is not None:
count += 1
sections = self.split(old, start, end, count, bytealigned)
lengths = [s.len for s in sections]
if len(lengths) == 1:
# Didn't find anything to replace.
return 0 # no replacements done
if new is self:
# Prevent self assignment woes
new = copy.copy(self)
positions = [lengths[0] + start]
for l in lengths[1:-1]:
# Next position is the previous one plus the length of the next section.
positions.append(positions[-1] + l)
# We have all the positions that need replacements. We do them
# in reverse order so that they won't move around as we replace.
positions.reverse()
try:
# Need to calculate new pos, if this is a bitstream
newpos = self._pos
for p in positions:
self[p:p + old.len] = new
if old.len != new.len:
diff = new.len - old.len
for p in positions:
if p >= newpos:
continue
if p + old.len <= newpos:
newpos += diff
else:
newpos = p
self._pos = newpos
except AttributeError:
for p in positions:
self[p:p + old.len] = new
assert self._assertsanity()
return len(lengths) - 1
|
[
"Replace all occurrences of old with new in place.\n\n Returns number of replacements made.\n\n old -- The bitstring to replace.\n new -- The replacement bitstring.\n start -- Any occurrences that start before this will not be replaced.\n Defaults to 0.\n end -- Any occurrences that finish after this will not be replaced.\n Defaults to self.len.\n count -- The maximum number of replacements to make. Defaults to\n replace all occurrences.\n bytealigned -- If True replacements will only be made on byte\n boundaries.\n\n Raises ValueError if old is empty or if start or end are\n out of range.\n\n "
] |
Please provide a description of the function:def insert(self, bs, pos=None):
bs = Bits(bs)
if not bs.len:
return self
if bs is self:
bs = self.__copy__()
if pos is None:
try:
pos = self._pos
except AttributeError:
raise TypeError("insert require a bit position for this type.")
if pos < 0:
pos += self.len
if not 0 <= pos <= self.len:
raise ValueError("Invalid insert position.")
self._insert(bs, pos)
|
[
"Insert bs at bit position pos.\n\n bs -- The bitstring to insert.\n pos -- The bit position to insert at.\n\n Raises ValueError if pos < 0 or pos > self.len.\n\n "
] |
Please provide a description of the function:def overwrite(self, bs, pos=None):
bs = Bits(bs)
if not bs.len:
return
if pos is None:
try:
pos = self._pos
except AttributeError:
raise TypeError("overwrite require a bit position for this type.")
if pos < 0:
pos += self.len
if pos < 0 or pos + bs.len > self.len:
raise ValueError("Overwrite exceeds boundary of bitstring.")
self._overwrite(bs, pos)
try:
self._pos = pos + bs.len
except AttributeError:
pass
|
[
"Overwrite with bs at bit position pos.\n\n bs -- The bitstring to overwrite with.\n pos -- The bit position to begin overwriting from.\n\n Raises ValueError if pos < 0 or pos + bs.len > self.len\n\n "
] |
Please provide a description of the function:def append(self, bs):
# The offset is a hint to make bs easily appendable.
bs = self._converttobitstring(bs, offset=(self.len + self._offset) % 8)
self._append(bs)
|
[
"Append a bitstring to the current bitstring.\n\n bs -- The bitstring to append.\n\n "
] |
Please provide a description of the function:def reverse(self, start=None, end=None):
start, end = self._validate_slice(start, end)
if start == 0 and end == self.len:
self._reverse()
return
s = self._slice(start, end)
s._reverse()
self[start:end] = s
|
[
"Reverse bits in-place.\n\n start -- Position of first bit to reverse. Defaults to 0.\n end -- One past the position of the last bit to reverse.\n Defaults to self.len.\n\n Using on an empty bitstring will have no effect.\n\n Raises ValueError if start < 0, end > self.len or end < start.\n\n "
] |
Please provide a description of the function:def set(self, value, pos=None):
f = self._set if value else self._unset
if pos is None:
pos = xrange(self.len)
try:
length = self.len
for p in pos:
if p < 0:
p += length
if not 0 <= p < length:
raise IndexError("Bit position {0} out of range.".format(p))
f(p)
except TypeError:
# Single pos
if pos < 0:
pos += self.len
if not 0 <= pos < length:
raise IndexError("Bit position {0} out of range.".format(pos))
f(pos)
|
[
"Set one or many bits to 1 or 0.\n\n value -- If True bits are set to 1, otherwise they are set to 0.\n pos -- Either a single bit position or an iterable of bit positions.\n Negative numbers are treated in the same way as slice indices.\n Defaults to the entire bitstring.\n\n Raises IndexError if pos < -self.len or pos >= self.len.\n\n "
] |
Please provide a description of the function:def invert(self, pos=None):
if pos is None:
self._invert_all()
return
if not isinstance(pos, collections.Iterable):
pos = (pos,)
length = self.len
for p in pos:
if p < 0:
p += length
if not 0 <= p < length:
raise IndexError("Bit position {0} out of range.".format(p))
self._invert(p)
|
[
"Invert one or many bits from 0 to 1 or vice versa.\n\n pos -- Either a single bit position or an iterable of bit positions.\n Negative numbers are treated in the same way as slice indices.\n\n Raises IndexError if pos < -self.len or pos >= self.len.\n\n "
] |
Please provide a description of the function:def ror(self, bits, start=None, end=None):
if not self.len:
raise Error("Cannot rotate an empty bitstring.")
if bits < 0:
raise ValueError("Cannot rotate right by negative amount.")
start, end = self._validate_slice(start, end)
bits %= (end - start)
if not bits:
return
rhs = self._slice(end - bits, end)
self._delete(bits, end - bits)
self._insert(rhs, start)
|
[
"Rotate bits to the right in-place.\n\n bits -- The number of bits to rotate by.\n start -- Start of slice to rotate. Defaults to 0.\n end -- End of slice to rotate. Defaults to self.len.\n\n Raises ValueError if bits < 0.\n\n "
] |
Please provide a description of the function:def rol(self, bits, start=None, end=None):
if not self.len:
raise Error("Cannot rotate an empty bitstring.")
if bits < 0:
raise ValueError("Cannot rotate left by negative amount.")
start, end = self._validate_slice(start, end)
bits %= (end - start)
if not bits:
return
lhs = self._slice(start, start + bits)
self._delete(bits, start)
self._insert(lhs, end - bits)
|
[
"Rotate bits to the left in-place.\n\n bits -- The number of bits to rotate by.\n start -- Start of slice to rotate. Defaults to 0.\n end -- End of slice to rotate. Defaults to self.len.\n\n Raises ValueError if bits < 0.\n\n "
] |
Please provide a description of the function:def byteswap(self, fmt=None, start=None, end=None, repeat=True):
start, end = self._validate_slice(start, end)
if fmt is None or fmt == 0:
# reverse all of the whole bytes.
bytesizes = [(end - start) // 8]
elif isinstance(fmt, numbers.Integral):
if fmt < 0:
raise ValueError("Improper byte length {0}.".format(fmt))
bytesizes = [fmt]
elif isinstance(fmt, basestring):
m = STRUCT_PACK_RE.match(fmt)
if not m:
raise ValueError("Cannot parse format string {0}.".format(fmt))
# Split the format string into a list of 'q', '4h' etc.
formatlist = re.findall(STRUCT_SPLIT_RE, m.group('fmt'))
# Now deal with multiplicative factors, 4h -> hhhh etc.
bytesizes = []
for f in formatlist:
if len(f) == 1:
bytesizes.append(PACK_CODE_SIZE[f])
else:
bytesizes.extend([PACK_CODE_SIZE[f[-1]]] * int(f[:-1]))
elif isinstance(fmt, collections.Iterable):
bytesizes = fmt
for bytesize in bytesizes:
if not isinstance(bytesize, numbers.Integral) or bytesize < 0:
raise ValueError("Improper byte length {0}.".format(bytesize))
else:
raise TypeError("Format must be an integer, string or iterable.")
repeats = 0
totalbitsize = 8 * sum(bytesizes)
if not totalbitsize:
return 0
if repeat:
# Try to repeat up to the end of the bitstring.
finalbit = end
else:
# Just try one (set of) byteswap(s).
finalbit = start + totalbitsize
for patternend in xrange(start + totalbitsize, finalbit + 1, totalbitsize):
bytestart = patternend - totalbitsize
for bytesize in bytesizes:
byteend = bytestart + bytesize * 8
self._reversebytes(bytestart, byteend)
bytestart += bytesize * 8
repeats += 1
return repeats
|
[
"Change the endianness in-place. Return number of repeats of fmt done.\n\n fmt -- A compact structure string, an integer number of bytes or\n an iterable of integers. Defaults to 0, which byte reverses the\n whole bitstring.\n start -- Start bit position, defaults to 0.\n end -- End bit position, defaults to self.len.\n repeat -- If True (the default) the byte swapping pattern is repeated\n as much as possible.\n\n "
] |
Please provide a description of the function:def _setbitpos(self, pos):
if pos < 0:
raise ValueError("Bit position cannot be negative.")
if pos > self.len:
raise ValueError("Cannot seek past the end of the data.")
self._pos = pos
|
[
"Move to absolute postion bit in bitstream."
] |
Please provide a description of the function:def read(self, fmt):
if isinstance(fmt, numbers.Integral):
if fmt < 0:
raise ValueError("Cannot read negative amount.")
if fmt > self.len - self._pos:
raise ReadError("Cannot read {0} bits, only {1} available.",
fmt, self.len - self._pos)
bs = self._slice(self._pos, self._pos + fmt)
self._pos += fmt
return bs
p = self._pos
_, token = tokenparser(fmt)
if len(token) != 1:
self._pos = p
raise ValueError("Format string should be a single token, not {0} "
"tokens - use readlist() instead.".format(len(token)))
name, length, _ = token[0]
if length is None:
length = self.len - self._pos
value, self._pos = self._readtoken(name, self._pos, length)
return value
|
[
"Interpret next bits according to the format string and return result.\n\n fmt -- Token string describing how to interpret the next bits.\n\n Token examples: 'int:12' : 12 bits as a signed integer\n 'uint:8' : 8 bits as an unsigned integer\n 'float:64' : 8 bytes as a big-endian float\n 'intbe:16' : 2 bytes as a big-endian signed integer\n 'uintbe:16' : 2 bytes as a big-endian unsigned integer\n 'intle:32' : 4 bytes as a little-endian signed integer\n 'uintle:32' : 4 bytes as a little-endian unsigned integer\n 'floatle:64': 8 bytes as a little-endian float\n 'intne:24' : 3 bytes as a native-endian signed integer\n 'uintne:24' : 3 bytes as a native-endian unsigned integer\n 'floatne:32': 4 bytes as a native-endian float\n 'hex:80' : 80 bits as a hex string\n 'oct:9' : 9 bits as an octal string\n 'bin:1' : single bit binary string\n 'ue' : next bits as unsigned exp-Golomb code\n 'se' : next bits as signed exp-Golomb code\n 'uie' : next bits as unsigned interleaved exp-Golomb code\n 'sie' : next bits as signed interleaved exp-Golomb code\n 'bits:5' : 5 bits as a bitstring\n 'bytes:10' : 10 bytes as a bytes object\n 'bool' : 1 bit as a bool\n 'pad:3' : 3 bits of padding to ignore - returns None\n\n fmt may also be an integer, which will be treated like the 'bits' token.\n\n The position in the bitstring is advanced to after the read items.\n\n Raises ReadError if not enough bits are available.\n Raises ValueError if the format is not understood.\n\n "
] |
Please provide a description of the function:def readlist(self, fmt, **kwargs):
value, self._pos = self._readlist(fmt, self._pos, **kwargs)
return value
|
[
"Interpret next bits according to format string(s) and return list.\n\n fmt -- A single string or list of strings with comma separated tokens\n describing how to interpret the next bits in the bitstring. Items\n can also be integers, for reading new bitstring of the given length.\n kwargs -- A dictionary or keyword-value pairs - the keywords used in the\n format string will be replaced with their given value.\n\n The position in the bitstring is advanced to after the read items.\n\n Raises ReadError is not enough bits are available.\n Raises ValueError if the format is not understood.\n\n See the docstring for 'read' for token examples. 'pad' tokens are skipped\n and not added to the returned list.\n\n >>> h, b1, b2 = s.readlist('hex:20, bin:5, bin:3')\n >>> i, bs1, bs2 = s.readlist(['uint:12', 10, 10])\n\n "
] |
Please provide a description of the function:def readto(self, bs, bytealigned=None):
if isinstance(bs, numbers.Integral):
raise ValueError("Integers cannot be searched for")
bs = Bits(bs)
oldpos = self._pos
p = self.find(bs, self._pos, bytealigned=bytealigned)
if not p:
raise ReadError("Substring not found")
self._pos += bs.len
return self._slice(oldpos, self._pos)
|
[
"Read up to and including next occurrence of bs and return result.\n\n bs -- The bitstring to find. An integer is not permitted.\n bytealigned -- If True the bitstring will only be\n found on byte boundaries.\n\n Raises ValueError if bs is empty.\n Raises ReadError if bs is not found.\n\n "
] |
Please provide a description of the function:def peek(self, fmt):
pos_before = self._pos
value = self.read(fmt)
self._pos = pos_before
return value
|
[
"Interpret next bits according to format string and return result.\n\n fmt -- Token string describing how to interpret the next bits.\n\n The position in the bitstring is not changed. If not enough bits are\n available then all bits to the end of the bitstring will be used.\n\n Raises ReadError if not enough bits are available.\n Raises ValueError if the format is not understood.\n\n See the docstring for 'read' for token examples.\n\n "
] |
Please provide a description of the function:def peeklist(self, fmt, **kwargs):
pos = self._pos
return_values = self.readlist(fmt, **kwargs)
self._pos = pos
return return_values
|
[
"Interpret next bits according to format string(s) and return list.\n\n fmt -- One or more strings with comma separated tokens describing\n how to interpret the next bits in the bitstring.\n kwargs -- A dictionary or keyword-value pairs - the keywords used in the\n format string will be replaced with their given value.\n\n The position in the bitstring is not changed. If not enough bits are\n available then all bits to the end of the bitstring will be used.\n\n Raises ReadError if not enough bits are available.\n Raises ValueError if the format is not understood.\n\n See the docstring for 'read' for token examples.\n\n "
] |
Please provide a description of the function:def bytealign(self):
skipped = (8 - (self._pos % 8)) % 8
self.pos += self._offset + skipped
assert self._assertsanity()
return skipped
|
[
"Align to next byte and return number of skipped bits.\n\n Raises ValueError if the end of the bitstring is reached before\n aligning to the next byte.\n\n "
] |
Please provide a description of the function:def prepend(self, bs):
bs = self._converttobitstring(bs)
self._prepend(bs)
self._pos += bs.len
|
[
"Prepend a bitstring to the current bitstring.\n\n bs -- The bitstring to prepend.\n\n "
] |
Please provide a description of the function:def find_inodes_in_use(fds):
self_pid = os.getpid()
id_fd_assoc = collections.defaultdict(list)
for fd in fds:
st = os.fstat(fd)
id_fd_assoc[(st.st_dev, st.st_ino)].append(fd)
def st_id_candidates(it):
# map proc paths to stat identifiers (devno and ino)
for proc_path in it:
try:
st = os.stat(proc_path)
except OSError as e:
# glob opens directories during matching,
# and other processes might close their fds in the meantime.
# This isn't a problem for the immutable-locked use case.
# ESTALE could happen with NFS or Docker
if e.errno in (errno.ENOENT, errno.ESTALE):
continue
raise
st_id = (st.st_dev, st.st_ino)
if st_id not in id_fd_assoc:
continue
yield proc_path, st_id
for proc_path, st_id in st_id_candidates(glob.glob('/proc/[1-9]*/fd/*')):
other_pid, other_fd = map(
int, PROC_PATH_RE.match(proc_path).groups())
original_fds = id_fd_assoc[st_id]
if other_pid == self_pid:
if other_fd in original_fds:
continue
use_info = proc_use_info(proc_path)
if not use_info:
continue
for fd in original_fds:
yield (fd, use_info)
# Requires Linux 3.3
for proc_path, st_id in st_id_candidates(
glob.glob('/proc/[1-9]*/map_files/*')
):
use_info = proc_use_info(proc_path)
if not use_info:
continue
original_fds = id_fd_assoc[st_id]
for fd in original_fds:
yield (fd, use_info)
|
[
"\n Find which of these inodes are in use, and give their open modes.\n\n Does not count the passed fds as an use of the inode they point to,\n but if the current process has the same inodes open with different\n file descriptors these will be listed.\n\n Looks at /proc/*/fd and /proc/*/map_files (Linux 3.3).\n Conceivably there are other uses we're missing, to be foolproof\n will require support in btrfs itself; a share-same-range ioctl\n would work well.\n "
] |
Please provide a description of the function:def set_idle_priority(pid=None):
if pid is None:
pid = os.getpid()
lib.ioprio_set(
lib.IOPRIO_WHO_PROCESS, pid,
lib.IOPRIO_PRIO_VALUE(lib.IOPRIO_CLASS_IDLE, 0))
|
[
"\n Puts a process in the idle io priority class.\n\n If pid is omitted, applies to the current process.\n "
] |
Please provide a description of the function:def futimens(fd, ns):
# ctime can't easily be reset
# also, we have no way to do mandatory locking without
# changing the ctime.
times = ffi.new('struct timespec[2]')
atime, mtime = ns
assert 0 <= atime.tv_nsec < 1e9
assert 0 <= mtime.tv_nsec < 1e9
times[0] = atime
times[1] = mtime
if lib.futimens(fd, times) != 0:
raise IOError(
ffi.errno, os.strerror(ffi.errno),
(fd, atime.tv_sec, atime.tv_nsec, mtime.tv_sec, mtime.tv_nsec))
|
[
"\n set inode atime and mtime\n\n ns is (atime, mtime), a pair of struct timespec\n with nanosecond resolution.\n "
] |
Please provide a description of the function:def fopenat(base_fd, path):
return os.fdopen(openat(base_fd, path, os.O_RDONLY), 'rb')
|
[
"\n Does openat read-only, then does fdopen to get a file object\n "
] |
Please provide a description of the function:def fopenat_rw(base_fd, path):
return os.fdopen(openat(base_fd, path, os.O_RDWR), 'rb+')
|
[
"\n Does openat read-write, then does fdopen to get a file object\n "
] |
Please provide a description of the function:def fiemap(fd):
count = 72
fiemap_cbuf = ffi.new(
'char[]',
ffi.sizeof('struct fiemap')
+ count * ffi.sizeof('struct fiemap_extent'))
fiemap_pybuf = ffi.buffer(fiemap_cbuf)
fiemap_ptr = ffi.cast('struct fiemap*', fiemap_cbuf)
assert ffi.sizeof(fiemap_cbuf) <= 4096
while True:
fiemap_ptr.fm_length = lib.FIEMAP_MAX_OFFSET
fiemap_ptr.fm_extent_count = count
fcntl.ioctl(fd, lib.FS_IOC_FIEMAP, fiemap_pybuf)
if fiemap_ptr.fm_mapped_extents == 0:
break
for i in range(fiemap_ptr.fm_mapped_extents):
extent = fiemap_ptr.fm_extents[i]
yield FiemapExtent(
extent.fe_logical, extent.fe_physical,
extent.fe_length, extent.fe_flags)
fiemap_ptr.fm_start = extent.fe_logical + extent.fe_length
|
[
"\n Gets a map of file extents.\n "
] |
Please provide a description of the function:def getflags(fd):
flags_ptr = ffi.new('uint64_t*')
flags_buf = ffi.buffer(flags_ptr)
fcntl.ioctl(fd, lib.FS_IOC_GETFLAGS, flags_buf)
return flags_ptr[0]
|
[
"\n Gets per-file filesystem flags.\n "
] |
Please provide a description of the function:def editflags(fd, add_flags=0, remove_flags=0):
if add_flags & remove_flags != 0:
raise ValueError(
'Added and removed flags shouldn\'t overlap',
add_flags, remove_flags)
# The ext2progs code uses int or unsigned long,
# the kernel uses an implicit int,
# let's be explicit here.
flags_ptr = ffi.new('uint64_t*')
flags_buf = ffi.buffer(flags_ptr)
fcntl.ioctl(fd, lib.FS_IOC_GETFLAGS, flags_buf)
prev_flags = flags_ptr[0]
flags_ptr[0] |= add_flags
# Python represents negative numbers with an infinite number of
# ones in bitops, so this will work correctly.
flags_ptr[0] &= ~remove_flags
fcntl.ioctl(fd, lib.FS_IOC_SETFLAGS, flags_buf)
return prev_flags & (add_flags | remove_flags)
|
[
"\n Sets and unsets per-file filesystem flags.\n "
] |
Please provide a description of the function:def connect(host, username, password, **kwargs):
arguments = ChainMap(kwargs, defaults)
transport = create_transport(host, **arguments)
protocol = ApiProtocol(transport=transport, encoding=arguments['encoding'])
api = arguments['subclass'](protocol=protocol)
for method in arguments['login_methods']:
try:
method(api=api, username=username, password=password)
return api
except (TrapError, MultiTrapError):
pass
except (ConnectionError, FatalError):
transport.close()
raise
|
[
"\n Connect and login to routeros device.\n Upon success return a Api class.\n\n :param host: Hostname to connecto to. May be ipv4,ipv6,FQDN.\n :param username: Username to login with.\n :param password: Password to login with. Only ASCII characters allowed.\n :param timeout: Socket timeout. Defaults to 10.\n :param port: Destination port to be used. Defaults to 8728.\n :param saddr: Source address to bind to.\n :param subclass: Subclass of Api class. Defaults to Api class from library.\n :param ssl_wrapper: Callable (e.g. ssl.SSLContext instance) to wrap socket with.\n :param login_methods: Tuple with callables to login methods to try in order.\n "
] |
Please provide a description of the function:def _readSentence(self):
reply_word, words = self.protocol.readSentence()
words = dict(parseWord(word) for word in words)
return reply_word, words
|
[
"\n Read one sentence and parse words.\n\n :returns: Reply word, dict with attribute words.\n "
] |
Please provide a description of the function:def _readResponse(self):
traps = []
reply_word = None
while reply_word != '!done':
reply_word, words = self._readSentence()
if reply_word == '!trap':
traps.append(TrapError(**words))
elif reply_word in ('!re', '!done') and words:
yield words
if len(traps) > 1:
raise MultiTrapError(*traps)
elif len(traps) == 1:
raise traps[0]
|
[
"\n Yield each row of response untill !done is received.\n\n :throws TrapError: If one !trap is received.\n :throws MultiTrapError: If > 1 !trap is received.\n "
] |
Please provide a description of the function:def encodeSentence(self, *words):
encoded = map(self.encodeWord, words)
encoded = b''.join(encoded)
# append EOS (end of sentence) byte
encoded += b'\x00'
return encoded
|
[
"\n Encode given sentence in API format.\n\n :param words: Words to endoce.\n :returns: Encoded sentence.\n "
] |
Please provide a description of the function:def encodeWord(self, word):
encoded_word = word.encode(encoding=self.encoding, errors='strict')
return Encoder.encodeLength(len(word)) + encoded_word
|
[
"\n Encode word in API format.\n\n :param word: Word to encode.\n :returns: Encoded word.\n "
] |
Please provide a description of the function:def encodeLength(length):
if length < 128:
ored_length = length
offset = -1
elif length < 16384:
ored_length = length | 0x8000
offset = -2
elif length < 2097152:
ored_length = length | 0xC00000
offset = -3
elif length < 268435456:
ored_length = length | 0xE0000000
offset = -4
else:
raise ConnectionError('Unable to encode length of {}'.format(length))
return pack('!I', ored_length)[offset:]
|
[
"\n Encode given length in mikrotik format.\n\n :param length: Integer < 268435456.\n :returns: Encoded length.\n "
] |
Please provide a description of the function:def determineLength(length):
integer = ord(length)
if integer < 128:
return 0
elif integer < 192:
return 1
elif integer < 224:
return 2
elif integer < 240:
return 3
else:
raise ConnectionError('Unknown controll byte {}'.format(length))
|
[
"\n Given first read byte, determine how many more bytes\n needs to be known in order to get fully encoded length.\n\n :param length: First read byte.\n :return: How many bytes to read.\n "
] |
Please provide a description of the function:def decodeLength(length):
bytes_length = len(length)
if bytes_length < 2:
offset = b'\x00\x00\x00'
XOR = 0
elif bytes_length < 3:
offset = b'\x00\x00'
XOR = 0x8000
elif bytes_length < 4:
offset = b'\x00'
XOR = 0xC00000
elif bytes_length < 5:
offset = b''
XOR = 0xE0000000
else:
raise ConnectionError('Unable to decode length of {}'.format(length))
decoded = unpack('!I', (offset + length))[0]
decoded ^= XOR
return decoded
|
[
"\n Decode length based on given bytes.\n\n :param length: Bytes string to decode.\n :return: Decoded length.\n "
] |
Please provide a description of the function:def writeSentence(self, cmd, *words):
encoded = self.encodeSentence(cmd, *words)
self.log('<---', cmd, *words)
self.transport.write(encoded)
|
[
"\n Write encoded sentence.\n\n :param cmd: Command word.\n :param words: Aditional words.\n "
] |
Please provide a description of the function:def readSentence(self):
sentence = tuple(word for word in iter(self.readWord, b''))
self.log('--->', *sentence)
reply_word, words = sentence[0], sentence[1:]
if reply_word == '!fatal':
self.transport.close()
raise FatalError(words[0])
else:
return reply_word, words
|
[
"\n Read every word untill empty word (NULL byte) is received.\n\n :return: Reply word, tuple with read words.\n "
] |
Please provide a description of the function:def read(self, length):
data = bytearray()
while len(data) != length:
data += self.sock.recv((length - len(data)))
if not data:
raise ConnectionError('Connection unexpectedly closed.')
return data
|
[
"\n Read as many bytes from socket as specified in length.\n Loop as long as every byte is read unless exception is raised.\n "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.