def _parse(self, stream, context, path):
try:
opcode = stream_read(stream, 1)[0]
if opcode == 0x7F:
raise ValidationError
len = opcode >> 7
# 1 byte opcode
if not len:
return self.type(opcode)
len = opcode >> 6
opcode = opcode << 8 | stream_read(stream, 1)[0]
# 2 byte opcode
if len == 2:
return self.type(opcode)
if len == 3:
opcode = opcode << 8 | stream_read(stream, 1)[0]
return self.type(opcode)
raise ValidationError
except ValueError:
raise ValidationError
def _parse(self, stream, context, path):
tiny = stream_read(stream, 1, path)[0]
if tiny != 0xff:
return tiny
big = stream_read(stream, 4, path)
return struct.unpack('<l', big)[0]
def _parse(self, stream, context, path):
property_id = stream_read(stream, 2)
format = property_id[0] & 0x01
if format:
property_id += stream_read(stream, 1)
length = (property_id[0] >> 1) + 1
sensor_setting_property_id = property_id[1] | property_id[2] << 8
sensor_setting_raw = list(stream_read(stream, length))
return Container(
format=1,
length=length,
sensor_setting_property_id=sensor_setting_property_id,
sensor_setting_raw=sensor_setting_raw
)
else:
length = ((property_id[0] >> 1) & 0b1111) + 1
sensor_setting_property_id = (property_id[0] >> 5 & 0b111) | property_id[1] << 3
sensor_setting_raw = PropertyDict[sensor_setting_property_id]._parse(stream, context, path)
return Container(
format=0,
length=length,
sensor_setting_property_id=sensor_setting_property_id,
sensor_setting_raw=sensor_setting_raw
)
def _parse(self, stream, context, path):
b = byte2int(stream_read(stream, 1, path))
extrabytes, mask = [
# lookup table
[0, 0xff], # (0b0xxxxxxx)
[0, 0xff], # (0b0xxxxxxx)
[1, 0x7f], # 0x80 (0b10xxxxxx)
[2, 0x00] # 0xC0 (0b11xxxxxx)
][b >> 6]
num = b & mask
for _ in range(extrabytes):
num = (num << 8) + byte2int(stream_read(stream, 1, path))
return num
def _parse(self, stream, context, path):
setting_property_id = stream_read(stream, 2)
format = setting_property_id[0] & 0x01
if format:
setting_property_id += stream_read(stream, 1)
length = (setting_property_id[0] >> 1) + 1
sensor_setting_property_id = setting_property_id[1] | setting_property_id[2] << 8
else:
length = ((setting_property_id[0] >> 1) & 0b1111) + 1
sensor_setting_property_id = (setting_property_id[0] >> 5 & 0b111) | setting_property_id[1] << 3
substream = io.BytesIO(stream.read(length))
return self._parse_sensor_setting(substream, context, path, sensor_setting_property_id, format=format, length=length)
def _parse(self, stream, context, path):
b = byte2int(stream_read(stream, 1, path))
extrabytes, mask = [
[0, 0xff],
[0, 0xff],
[0, 0xff],
[0, 0xff], # (0b0..xxxxx)
[1, 0x7f],
[1, 0x7f], # 0x80 (0b10.xxxxx)
[3, 0x3f], # 0xC0 (0b110xxxxx)
[4, 0x00] # 0xE0 (0b111xxxxx)
][b >> 5]
num = b & mask
for _ in range(extrabytes):
num = (num << 8) + byte2int(stream_read(stream, 1, path))
return num
def _parse(self, stream, context, path):
data = stream_read(stream, self.length, "WhateverPath")
data = swapbitsinbytes(data)
try:
return self.packer.unpack(data)[0]
except Exception:
raise FormatFieldError("struct %r error during parsing" %
self.fmtstr)
def _parse(self, stream, context, path):
acc = []
while True:
b = byte2int(stream_read(stream, 1))
acc.append(b & 0b01111111)
if not b & 0b10000000:
break
num = 0
for b in acc:
num = (num << 7) | b
return num
def _check_placeholder(self, stream, path):
'''
Does a sanity check by comparing the data at the target location with the expected placeholder
'''
# seek to target offset, check if data matches originally written placeholder data
with seek_temporary(stream, path, self.target_offset):
read_data = stream_read(stream, len(self.placeholder_data), path)
if read_data != self.placeholder_data:
raise DeferredError(
f'something went wrong, data at target location ({read_data.hex()}) does not equal expected placeholder data ({self.placeholder_data.hex()})',
path=path)
def _parse(self, stream, context, path):
length = self.length
if callable(length):
length = length(context)
if length < 0:
raise IntegerError("length must be non-negative")
data = stream_read(stream, length, "WhateverPath")
if self.swapped:
if length & 7:
raise IntegerError(
"little-endianness is only defined for multiples of 8 bits"
)
data = swapbytes(data)
data = data[::-1]
return bits2integer(data, self.signed)
def _parse(self, stream, context, path):
result = 0
sign = 1
i = 0
depth = 0
while True:
length = self.lengths[i]
bits = byte2int(stream_read(stream, 1, path))
mask = self._get_data_mask(length)
data = bits & mask
more = self._get_more_bit(length) & bits
if (i == 0) and (self.negative_bit & bits):
sign = -1
result |= data << depth
if not more:
break
i += 1
depth += length
return sign * result
def _parse(self, stream, context, path):
obj = self.subcon._parsereport(stream, context, path)
pad = self._pad(stream, path)
stream_read(stream, pad, path)
return obj
