How to use the msgpack.exceptions.UnpackValueError function in msgpack

To help you get started, we’ve selected a few msgpack examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github pymedusa / Medusa / ext / msgpack / fallback.py View on Github external
self._buff_i += 2
            if n > self._max_array_len:
                raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
        elif b == 0xdd:
            typ = TYPE_ARRAY
            self._reserve(4)
            n, = struct.unpack_from(">I", self._buffer, self._buff_i)
            self._buff_i += 4
            if n > self._max_array_len:
                raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
        elif b == 0xde:
            self._reserve(2)
            n, = struct.unpack_from(">H", self._buffer, self._buff_i)
            self._buff_i += 2
            if n > self._max_map_len:
                raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
            typ = TYPE_MAP
        elif b == 0xdf:
            self._reserve(4)
            n, = struct.unpack_from(">I", self._buffer, self._buff_i)
            self._buff_i += 4
            if n > self._max_map_len:
                raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
            typ = TYPE_MAP
        else:
            raise UnpackValueError("Unknown header: 0x%x" % b)
        return typ, n, obj
github pymedusa / Medusa / ext / msgpack / fallback.py View on Github external
def unpackb(packed, **kwargs):
    """
    Unpack an object from `packed`.

    Raises `ExtraData` when `packed` contains extra bytes.
    See :class:`Unpacker` for options.
    """
    unpacker = Unpacker(None, **kwargs)
    unpacker.feed(packed)
    try:
        ret = unpacker._unpack()
    except OutOfData:
        raise UnpackValueError("Data is not enough.")
    if unpacker._got_extradata():
        raise ExtraData(ret, unpacker._get_extradata())
    return ret
github JordanDelcros / OBJImg / resources / three / 73 / utils / converters / msgpack / msgpack / fallback.py View on Github external
def _fb_unpack(self, execute=EX_CONSTRUCT, write_bytes=None):
        typ, n, obj = self._read_header(execute, write_bytes)

        if execute == EX_READ_ARRAY_HEADER:
            if typ != TYPE_ARRAY:
                raise UnpackValueError("Expected array")
            return n
        if execute == EX_READ_MAP_HEADER:
            if typ != TYPE_MAP:
                raise UnpackValueError("Expected map")
            return n
        # TODO should we eliminate the recursion?
        if typ == TYPE_ARRAY:
            if execute == EX_SKIP:
                for i in xrange(n):
                    # TODO check whether we need to call `list_hook`
                    self._fb_unpack(EX_SKIP, write_bytes)
                return
            ret = newlist_hint(n)
            for i in xrange(n):
                ret.append(self._fb_unpack(EX_CONSTRUCT, write_bytes))
            if self._list_hook is not None:
                ret = self._list_hook(ret)
            # TODO is the interaction between `list_hook` and `use_list` ok?
            return ret if self._use_list else tuple(ret)
        if typ == TYPE_MAP:
github opendxl / opendxl-client-python / dxlclient / _vendor / msgpack / fallback.py View on Github external
def unpackb(packed, **kwargs):
    """
    Unpack an object from `packed`.

    Raises `ExtraData` when `packed` contains extra bytes.
    See :class:`Unpacker` for options.
    """
    unpacker = Unpacker(None, **kwargs)
    unpacker.feed(packed)
    try:
        ret = unpacker._fb_unpack()
    except OutOfData:
        raise UnpackValueError("Data is not enough.")
    if unpacker._fb_got_extradata():
        raise ExtraData(ret, unpacker._fb_get_extradata())
    return ret
github pymedusa / Medusa / ext / msgpack / fallback.py View on Github external
if self._max_ext_len < 4:
                raise UnpackValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len))
            self._reserve(5)
            n, obj = struct.unpack_from("b4s", self._buffer, self._buff_i)
            self._buff_i += 5
        elif b == 0xd7:  # fixext 8
            typ = TYPE_EXT
            if self._max_ext_len < 8:
                raise UnpackValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len))
            self._reserve(9)
            n, obj = struct.unpack_from("b8s", self._buffer, self._buff_i)
            self._buff_i += 9
        elif b == 0xd8:  # fixext 16
            typ = TYPE_EXT
            if self._max_ext_len < 16:
                raise UnpackValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len))
            self._reserve(17)
            n, obj = struct.unpack_from("b16s", self._buffer, self._buff_i)
            self._buff_i += 17
        elif b == 0xd9:
            typ = TYPE_RAW
            self._reserve(1)
            n = self._buffer[self._buff_i]
            self._buff_i += 1
            if n > self._max_str_len:
                raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
            obj = self._read(n)
        elif b == 0xda:
            typ = TYPE_RAW
            self._reserve(2)
            n, = struct.unpack_from(">H", self._buffer, self._buff_i)
            self._buff_i += 2
github JordanDelcros / OBJImg / resources / three / 73 / utils / converters / msgpack / msgpack / fallback.py View on Github external
def _fb_unpack(self, execute=EX_CONSTRUCT, write_bytes=None):
        typ, n, obj = self._read_header(execute, write_bytes)

        if execute == EX_READ_ARRAY_HEADER:
            if typ != TYPE_ARRAY:
                raise UnpackValueError("Expected array")
            return n
        if execute == EX_READ_MAP_HEADER:
            if typ != TYPE_MAP:
                raise UnpackValueError("Expected map")
            return n
        # TODO should we eliminate the recursion?
        if typ == TYPE_ARRAY:
            if execute == EX_SKIP:
                for i in xrange(n):
                    # TODO check whether we need to call `list_hook`
                    self._fb_unpack(EX_SKIP, write_bytes)
                return
            ret = newlist_hint(n)
            for i in xrange(n):
                ret.append(self._fb_unpack(EX_CONSTRUCT, write_bytes))
            if self._list_hook is not None:
github pymedusa / Medusa / ext / msgpack / fallback.py View on Github external
obj = True
        elif b == 0xc4:
            typ = TYPE_BIN
            self._reserve(1)
            n = self._buffer[self._buff_i]
            self._buff_i += 1
            if n > self._max_bin_len:
                raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
            obj = self._read(n)
        elif b == 0xc5:
            typ = TYPE_BIN
            self._reserve(2)
            n = struct.unpack_from(">H", self._buffer, self._buff_i)[0]
            self._buff_i += 2
            if n > self._max_bin_len:
                raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
            obj = self._read(n)
        elif b == 0xc6:
            typ = TYPE_BIN
            self._reserve(4)
            n = struct.unpack_from(">I", self._buffer, self._buff_i)[0]
            self._buff_i += 4
            if n > self._max_bin_len:
                raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
            obj = self._read(n)
        elif b == 0xc7:  # ext 8
            typ = TYPE_EXT
            self._reserve(2)
            L, n = struct.unpack_from('Bb', self._buffer, self._buff_i)
            self._buff_i += 2
            if L > self._max_ext_len:
                raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
github opendxl / opendxl-client-python / dxlclient / _vendor / msgpack / fallback.py View on Github external
def _fb_unpack(self, execute=EX_CONSTRUCT, write_bytes=None):
        typ, n, obj = self._read_header(execute, write_bytes)

        if execute == EX_READ_ARRAY_HEADER:
            if typ != TYPE_ARRAY:
                raise UnpackValueError("Expected array")
            return n
        if execute == EX_READ_MAP_HEADER:
            if typ != TYPE_MAP:
                raise UnpackValueError("Expected map")
            return n
        # TODO should we eliminate the recursion?
        if typ == TYPE_ARRAY:
            if execute == EX_SKIP:
                for i in xrange(n):
                    # TODO check whether we need to call `list_hook`
                    self._fb_unpack(EX_SKIP, write_bytes)
                return
            ret = newlist_hint(n)
            for i in xrange(n):
                ret.append(self._fb_unpack(EX_CONSTRUCT, write_bytes))
            if self._list_hook is not None:
                ret = self._list_hook(ret)
            # TODO is the interaction between `list_hook` and `use_list` ok?
            return ret if self._use_list else tuple(ret)
        if typ == TYPE_MAP:
github pymedusa / Medusa / ext / msgpack / fallback.py View on Github external
self._buff_i += 1
        if b & 0b10000000 == 0:
            obj = b
        elif b & 0b11100000 == 0b11100000:
            obj = -1 - (b ^ 0xff)
        elif b & 0b11100000 == 0b10100000:
            n = b & 0b00011111
            typ = TYPE_RAW
            if n > self._max_str_len:
                raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
            obj = self._read(n)
        elif b & 0b11110000 == 0b10010000:
            n = b & 0b00001111
            typ = TYPE_ARRAY
            if n > self._max_array_len:
                raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
        elif b & 0b11110000 == 0b10000000:
            n = b & 0b00001111
            typ = TYPE_MAP
            if n > self._max_map_len:
                raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
        elif b == 0xc0:
            obj = None
        elif b == 0xc2:
            obj = False
        elif b == 0xc3:
            obj = True
        elif b == 0xc4:
            typ = TYPE_BIN
            self._reserve(1)
            n = self._buffer[self._buff_i]
            self._buff_i += 1