[Python-modules-commits] [u-msgpack-python] 01/03: Import u-msgpack-python_2.3.0.orig.tar.gz
Orestis Ioannou
oorestisime-guest at moszumanska.debian.org
Thu Mar 30 19:50:11 UTC 2017
This is an automated email from the git hooks/post-receive script.
oorestisime-guest pushed a commit to branch master
in repository u-msgpack-python.
commit 634caa76c24d7e23fcc102191ee25cb4795459f7
Author: Orestis Ioannou <orestis at oioannou.com>
Date: Wed Mar 22 23:54:29 2017 +0100
Import u-msgpack-python_2.3.0.orig.tar.gz
---
LICENSE | 19 ++
MANIFEST.in | 2 +
PKG-INFO | 4 +-
setup.cfg | 11 +
setup.py | 12 +-
test_umsgpack.py | 421 +++++++++++++++++++++++++
PKG-INFO => u_msgpack_python.egg-info/PKG-INFO | 4 +-
u_msgpack_python.egg-info/SOURCES.txt | 10 +
u_msgpack_python.egg-info/dependency_links.txt | 1 +
u_msgpack_python.egg-info/top_level.txt | 1 +
umsgpack.py | 289 +++++++++++------
11 files changed, 665 insertions(+), 109 deletions(-)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7e330d5
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,19 @@
+ Copyright (c) 2013-2016 vsergeev / Ivan (Vanya) A. Sergeev
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..6ffd061
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,2 @@
+include LICENSE
+include test_umsgpack.py
diff --git a/PKG-INFO b/PKG-INFO
index 67063be..1dfe610 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,10 +1,10 @@
Metadata-Version: 1.1
Name: u-msgpack-python
-Version: 2.1
+Version: 2.3.0
Summary: A portable, lightweight MessagePack serializer and deserializer written in pure Python.
Home-page: https://github.com/vsergeev/u-msgpack-python
Author: vsergeev
-Author-email: vsergeev at gmail
+Author-email: v at sergeev.io
License: MIT
Description: u-msgpack-python is a lightweight `MessagePack <http://msgpack.org/>`_ serializer and deserializer module written in pure Python, compatible with both Python 2 and Python 3, as well as CPython and PyPy implementations of Python. u-msgpack-python is fully compliant with the latest `MessagePack specification <https://github.com/msgpack/msgpack/blob/master/spec.md>`_. In particular, it supports the new binary, UTF-8 string, and application-defined ext types. See https://github. [...]
Keywords: msgpack serialization deserialization
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..73051f9
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,11 @@
+[metadata]
+description-file = README.md
+
+[bdist_wheel]
+universal = True
+
+[egg_info]
+tag_build =
+tag_date = 0
+tag_svn_revision = 0
+
diff --git a/setup.py b/setup.py
index fa314b0..b326345 100644
--- a/setup.py
+++ b/setup.py
@@ -1,11 +1,14 @@
-from distutils.core import setup
+try:
+ from setuptools import setup
+except ImportError:
+ from distutils.core import setup
setup(
name='u-msgpack-python',
- version='2.1',
+ version='2.3.0',
description='A portable, lightweight MessagePack serializer and deserializer written in pure Python.',
author='vsergeev',
- author_email='vsergeev at gmail',
+ author_email='v at sergeev.io',
url='https://github.com/vsergeev/u-msgpack-python',
py_modules=['umsgpack'],
long_description="""u-msgpack-python is a lightweight `MessagePack <http://msgpack.org/>`_ serializer and deserializer module written in pure Python, compatible with both Python 2 and Python 3, as well as CPython and PyPy implementations of Python. u-msgpack-python is fully compliant with the latest `MessagePack specification <https://github.com/msgpack/msgpack/blob/master/spec.md>`_. In particular, it supports the new binary, UTF-8 string, and application-defined ext types. See http [...]
@@ -21,5 +24,4 @@ setup(
],
license='MIT',
keywords='msgpack serialization deserialization',
- )
-
+)
diff --git a/test_umsgpack.py b/test_umsgpack.py
new file mode 100644
index 0000000..3754e47
--- /dev/null
+++ b/test_umsgpack.py
@@ -0,0 +1,421 @@
+# -*- coding: utf-8 -*-
+# Run test_umsgpack.py with your Python interpreter of choice to test the
+# correctness of u-msgpack-python!
+#
+# $ python2 test_umsgpack.py
+# $ python3 test_umsgpack.py
+# $ pypy test_umsgpack.py
+# $ pypy3 test_umsgpack.py
+#
+
+import sys
+import struct
+import unittest
+import io
+from collections import OrderedDict, namedtuple
+
+import umsgpack
+
+single_test_vectors = [
+ # None
+ [ "nil", None, b"\xc0" ],
+ # Booleans
+ [ "bool false", False, b"\xc2" ],
+ [ "bool true", True, b"\xc3" ],
+ # + 7-bit uint
+ [ "7-bit uint", 0x00, b"\x00" ],
+ [ "7-bit uint", 0x10, b"\x10" ],
+ [ "7-bit uint", 0x7f, b"\x7f" ],
+ # - 5-bit int
+ [ "5-bit sint", -1, b"\xff" ],
+ [ "5-bit sint", -16, b"\xf0" ],
+ [ "5-bit sint", -32, b"\xe0" ],
+ # 8-bit uint
+ [ "8-bit uint", 0x80, b"\xcc\x80" ],
+ [ "8-bit uint", 0xf0, b"\xcc\xf0" ],
+ [ "8-bit uint", 0xff, b"\xcc\xff" ],
+ # 16-bit uint
+ [ "16-bit uint", 0x100, b"\xcd\x01\x00" ],
+ [ "16-bit uint", 0x2000, b"\xcd\x20\x00" ],
+ [ "16-bit uint", 0xffff, b"\xcd\xff\xff" ],
+ # 32-bit uint
+ [ "32-bit uint", 0x10000, b"\xce\x00\x01\x00\x00" ],
+ [ "32-bit uint", 0x200000, b"\xce\x00\x20\x00\x00" ],
+ [ "32-bit uint", 0xffffffff, b"\xce\xff\xff\xff\xff" ],
+ # 64-bit uint
+ [ "64-bit uint", 0x100000000, b"\xcf\x00\x00\x00\x01\x00\x00\x00\x00" ],
+ [ "64-bit uint", 0x200000000000, b"\xcf\x00\x00\x20\x00\x00\x00\x00\x00" ],
+ [ "64-bit uint", 0xffffffffffffffff, b"\xcf\xff\xff\xff\xff\xff\xff\xff\xff" ],
+ # 8-bit int
+ [ "8-bit int", -33, b"\xd0\xdf" ],
+ [ "8-bit int", -100, b"\xd0\x9c" ],
+ [ "8-bit int", -128, b"\xd0\x80" ],
+ # 16-bit int
+ [ "16-bit int", -129, b"\xd1\xff\x7f" ],
+ [ "16-bit int", -2000, b"\xd1\xf8\x30" ],
+ [ "16-bit int", -32768, b"\xd1\x80\x00" ],
+ # 32-bit int
+ [ "32-bit int", -32769, b"\xd2\xff\xff\x7f\xff" ],
+ [ "32-bit int", -1000000000, b"\xd2\xc4\x65\x36\x00" ],
+ [ "32-bit int", -2147483648, b"\xd2\x80\x00\x00\x00" ],
+ # 64-bit int
+ [ "64-bit int", -2147483649, b"\xd3\xff\xff\xff\xff\x7f\xff\xff\xff" ],
+ [ "64-bit int", -1000000000000000002, b"\xd3\xf2\x1f\x49\x4c\x58\x9b\xff\xfe" ],
+ [ "64-bit int", -9223372036854775808, b"\xd3\x80\x00\x00\x00\x00\x00\x00\x00" ],
+ # 64-bit float
+ [ "64-bit float", 0.0, b"\xcb\x00\x00\x00\x00\x00\x00\x00\x00" ],
+ [ "64-bit float", 2.5, b"\xcb\x40\x04\x00\x00\x00\x00\x00\x00" ],
+ [ "64-bit float", float(10**35), b"\xcb\x47\x33\x42\x61\x72\xc7\x4d\x82" ],
+ # Fixstr String
+ [ "fix string", u"", b"\xa0" ],
+ [ "fix string", u"a", b"\xa1\x61" ],
+ [ "fix string", u"abc", b"\xa3\x61\x62\x63" ],
+ [ "fix string", u"a"*31, b"\xbf" + b"\x61"*31 ],
+ # 8-bit String
+ [ "8-bit string", u"b"*32, b"\xd9\x20" + b"b"*32 ],
+ [ "8-bit string", u"c"*100, b"\xd9\x64" + b"c"*100 ],
+ [ "8-bit string", u"d"*255, b"\xd9\xff" + b"d"*255 ],
+ # 16-bit String
+ [ "16-bit string", u"b"*256, b"\xda\x01\x00" + b"b"*256 ],
+ [ "16-bit string", u"c"*65535, b"\xda\xff\xff" + b"c"*65535 ],
+ # 32-bit String
+ [ "32-bit string", u"b"*65536, b"\xdb\x00\x01\x00\x00" + b"b"*65536 ],
+ # Wide character String
+ [ "wide char string", u"Allagbé", b"\xa8Allagb\xc3\xa9" ],
+ [ "wide char string", u"По оживлённым берегам", b"\xd9\x28\xd0\x9f\xd0\xbe\x20\xd0\xbe\xd0\xb6\xd0\xb8\xd0\xb2\xd0\xbb\xd1\x91\xd0\xbd\xd0\xbd\xd1\x8b\xd0\xbc\x20\xd0\xb1\xd0\xb5\xd1\x80\xd0\xb5\xd0\xb3\xd0\xb0\xd0\xbc" ],
+ # 8-bit Binary
+ [ "8-bit binary", b"\x80"*1, b"\xc4\x01" + b"\x80"*1 ],
+ [ "8-bit binary", b"\x80"*32, b"\xc4\x20" + b"\x80"*32 ],
+ [ "8-bit binary", b"\x80"*255, b"\xc4\xff" + b"\x80"*255 ],
+ # 16-bit Binary
+ [ "16-bit binary", b"\x80"*256, b"\xc5\x01\x00" + b"\x80"*256 ],
+ # 32-bit Binary
+ [ "32-bit binary", b"\x80"*65536, b"\xc6\x00\x01\x00\x00" + b"\x80"*65536 ],
+ # Fixext 1
+ [ "fixext 1", umsgpack.Ext(0x05, b"\x80"*1), b"\xd4\x05" + b"\x80"*1 ],
+ # Fixext 2
+ [ "fixext 2", umsgpack.Ext(0x05, b"\x80"*2), b"\xd5\x05" + b"\x80"*2 ],
+ # Fixext 4
+ [ "fixext 4", umsgpack.Ext(0x05, b"\x80"*4), b"\xd6\x05" + b"\x80"*4 ],
+ # Fixext 8
+ [ "fixext 8", umsgpack.Ext(0x05, b"\x80"*8), b"\xd7\x05" + b"\x80"*8 ],
+ # Fixext 16
+ [ "fixext 16", umsgpack.Ext(0x05, b"\x80"*16), b"\xd8\x05" + b"\x80"*16 ],
+ # 8-bit Ext
+ [ "8-bit ext", umsgpack.Ext(0x05, b"\x80"*255), b"\xc7\xff\x05" + b"\x80"*255 ],
+ # 16-bit Ext
+ [ "16-bit ext", umsgpack.Ext(0x05, b"\x80"*256), b"\xc8\x01\x00\x05" + b"\x80"*256 ],
+ # 32-bit Ext
+ [ "32-bit ext", umsgpack.Ext(0x05, b"\x80"*65536), b"\xc9\x00\x01\x00\x00\x05" + b"\x80"*65536 ],
+ # Empty Array
+ [ "empty array", [], b"\x90" ],
+ # Empty Map
+ [ "empty map", {}, b"\x80" ],
+]
+
+composite_test_vectors = [
+ # Fix Array
+ [ "fix array", [ 5, u"abc", True ], b"\x93\x05\xa3\x61\x62\x63\xc3" ],
+ # 16-bit Array
+ [ "16-bit array", [ 0x05 ]*16, b"\xdc\x00\x10" + b"\x05"*16 ],
+ [ "16-bit array", [ 0x05 ]*65535, b"\xdc\xff\xff" + b"\x05"*65535 ],
+ # 32-bit Array
+ [ "32-bit array", [ 0x05 ]*65536, b"\xdd\x00\x01\x00\x00" + b"\x05"*65536 ],
+ # Fix Map
+ [ "fix map", OrderedDict([(1, True), (2, u"abc"), (3, b"\x80")]), b"\x83\x01\xc3\x02\xa3\x61\x62\x63\x03\xc4\x01\x80" ],
+ [ "fix map", { u"abc" : 5 }, b"\x81\xa3\x61\x62\x63\x05" ],
+ [ "fix map", { b"\x80" : 0xffff }, b"\x81\xc4\x01\x80\xcd\xff\xff" ],
+ [ "fix map", { True : None }, b"\x81\xc3\xc0" ],
+ # 16-bit Map
+ [ "16-bit map", OrderedDict([(k, 0x05) for k in range(16)]), b"\xde\x00\x10" + b"".join([struct.pack("B", i) + b"\x05" for i in range(16)])],
+ [ "16-bit map", OrderedDict([(k, 0x05) for k in range(6000)]), b"\xde\x17\x70" + b"".join([struct.pack("B", i) + b"\x05" for i in range(128)]) + b"".join([b"\xcc" + struct.pack("B", i) + b"\x05" for i in range(128, 256)]) + b"".join([b"\xcd" + struct.pack(">H", i) + b"\x05" for i in range(256, 6000)]) ],
+ # Complex Array
+ [ "complex array", [ True, 0x01, umsgpack.Ext(0x03, b"foo"), 0xff, OrderedDict([(1, False), (2, u"abc")]), b"\x80", [1, 2, 3], u"abc" ], b"\x98\xc3\x01\xc7\x03\x03\x66\x6f\x6f\xcc\xff\x82\x01\xc2\x02\xa3\x61\x62\x63\xc4\x01\x80\x93\x01\x02\x03\xa3\x61\x62\x63" ],
+ # Complex Map
+ [ "complex map", OrderedDict([(1, [OrderedDict([(1, 2), (3, 4)]), {}]), (2, 1), (3, [False, u"def"]), (4, OrderedDict([(0x100000000, u"a"), (0xffffffff, u"b")]))]), b"\x84\x01\x92\x82\x01\x02\x03\x04\x80\x02\x01\x03\x92\xc2\xa3\x64\x65\x66\x04\x82\xcf\x00\x00\x00\x01\x00\x00\x00\x00\xa1\x61\xce\xff\xff\xff\xff\xa1\x62" ],
+ # Map with Tuple Keys
+ [ "map with tuple keys", OrderedDict([((u"foo", False, 3), True), ((3e6, -5), u"def")]), b"\x82\x93\xa3\x66\x6f\x6f\xc2\x03\xc3\x92\xcb\x41\x46\xe3\x60\x00\x00\x00\x00\xfb\xa3\x64\x65\x66" ],
+ # Map with Complex Tuple Keys
+ [ "map with complex tuple keys", {(u"foo", (1,2,3), 3) : -5}, b"\x81\x93\xa3\x66\x6f\x6f\x93\x01\x02\x03\x03\xfb" ]
+]
+
+pack_exception_test_vectors = [
+ # Unsupported type exception
+ [ "unsupported type", set([1,2,3]), umsgpack.UnsupportedTypeException ],
+ [ "unsupported type", -2**(64-1)-1, umsgpack.UnsupportedTypeException ],
+ [ "unsupported type", 2**64, umsgpack.UnsupportedTypeException ],
+]
+
+unpack_exception_test_vectors = [
+ # Type errors
+ [ "type error unpack unicode string", u"\x01", TypeError ],
+ [ "type error unpack boolean", True, TypeError ],
+ # Insufficient data to unpack object
+ [ "insufficient data 8-bit uint", b"\xcc", umsgpack.InsufficientDataException ],
+ [ "insufficient data 16-bit uint", b"\xcd\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit uint", b"\xce\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 64-bit uint", b"\xcf\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 8-bit int", b"\xd0", umsgpack.InsufficientDataException ],
+ [ "insufficient data 16-bit int", b"\xd1\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit int", b"\xd2\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 64-bit int", b"\xd3\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit float", b"\xca\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data 64-bit float", b"\xcb\xff", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixstr", b"\xa1", umsgpack.InsufficientDataException ],
+ [ "insufficient data 8-bit string", b"\xd9", umsgpack.InsufficientDataException ],
+ [ "insufficient data 8-bit string", b"\xd9\x01", umsgpack.InsufficientDataException ],
+ [ "insufficient data 16-bit string", b"\xda\x01\x00", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit string", b"\xdb\x00\x01\x00\x00", umsgpack.InsufficientDataException ],
+ [ "insufficient data 8-bit binary", b"\xc4", umsgpack.InsufficientDataException ],
+ [ "insufficient data 8-bit binary", b"\xc4\x01", umsgpack.InsufficientDataException ],
+ [ "insufficient data 16-bit binary", b"\xc5\x01\x00", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit binary", b"\xc6\x00\x01\x00\x00", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixarray", b"\x91", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixarray", b"\x92\xc2", umsgpack.InsufficientDataException ],
+ [ "insufficient data 16-bit array", b"\xdc\x00\xf0\xc2\xc3", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit array", b"\xdd\x00\x01\x00\x00\xc2\xc3", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixmap", b"\x81", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixmap", b"\x82\xc2\xc3", umsgpack.InsufficientDataException ],
+ [ "insufficient data 16-bit map", b"\xde\x00\xf0\xc2\xc3", umsgpack.InsufficientDataException ],
+ [ "insufficient data 32-bit map", b"\xdf\x00\x01\x00\x00\xc2\xc3", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixext 1", b"\xd4", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixext 1", b"\xd4\x05", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixext 2", b"\xd5\x05\x01", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixext 4", b"\xd6\x05\x01\x02\x03", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixext 8", b"\xd7\x05\x01\x02\x03", umsgpack.InsufficientDataException ],
+ [ "insufficient data fixext 16", b"\xd8\x05\x01\x02\x03", umsgpack.InsufficientDataException ],
+ [ "insufficient data ext 8-bit", b"\xc7\x05\x05\x01\x02\x03", umsgpack.InsufficientDataException ],
+ [ "insufficient data ext 16-bit", b"\xc8\x01\x00\x05\x01\x02\x03", umsgpack.InsufficientDataException ],
+ [ "insufficient data ext 32-bit", b"\xc9\x00\x01\x00\x00\x05\x01\x02\x03", umsgpack.InsufficientDataException ],
+ # Unhashable key { 1 : True, { 1 : 1 } : False }
+ [ "unhashable key", b"\x82\x01\xc3\x81\x01\x01\xc2", umsgpack.UnhashableKeyException ],
+ # Unhashable key { [ 1, 2, {} ] : True }
+ [ "unhashable key", b"\x81\x93\x01\x02\x80\xc3", umsgpack.UnhashableKeyException ],
+ # Key duplicate { 1 : True, 1 : False }
+ [ "duplicate key", b"\x82\x01\xc3\x01\xc2", umsgpack.DuplicateKeyException ],
+ # Reserved code (0xc1)
+ [ "reserved code", b"\xc1", umsgpack.ReservedCodeException ],
+ # Invalid string (non utf-8)
+ [ "invalid string", b"\xa1\x80", umsgpack.InvalidStringException ],
+]
+
+compatibility_test_vectors = [
+ # Fix Raw
+ [ "fix raw", b"", b"\xa0" ],
+ [ "fix raw", u"", b"\xa0" ],
+ [ "fix raw", b"a", b"\xa1\x61" ],
+ [ "fix raw", u"a", b"\xa1\x61" ],
+ [ "fix raw", b"abc", b"\xa3\x61\x62\x63" ],
+ [ "fix raw", u"abc", b"\xa3\x61\x62\x63" ],
+ [ "fix raw", b"a"*31, b"\xbf" + b"\x61"*31 ],
+ [ "fix raw", u"a"*31, b"\xbf" + b"\x61"*31 ],
+ # 16-bit Raw
+ [ "16-bit raw", u"b"*32, b"\xda\x00\x20" + b"b"*32 ],
+ [ "16-bit raw", b"b"*32, b"\xda\x00\x20" + b"b"*32 ],
+ [ "16-bit raw", u"b"*256, b"\xda\x01\x00" + b"b"*256 ],
+ [ "16-bit raw", b"b"*256, b"\xda\x01\x00" + b"b"*256 ],
+ [ "16-bit raw", u"c"*65535, b"\xda\xff\xff" + b"c"*65535 ],
+ [ "16-bit raw", b"c"*65535, b"\xda\xff\xff" + b"c"*65535 ],
+ # 32-bit Raw
+ [ "32-bit raw", u"b"*65536, b"\xdb\x00\x01\x00\x00" + b"b"*65536 ],
+ [ "32-bit raw", b"b"*65536, b"\xdb\x00\x01\x00\x00" + b"b"*65536 ],
+]
+
+CustomType = namedtuple('CustomType', ['x', 'y', 'z'])
+
+ext_handlers = {
+ complex: lambda obj: umsgpack.Ext(0x20, struct.pack("ff", obj.real, obj.imag)),
+ CustomType: lambda obj: umsgpack.Ext(0x30, umsgpack.packb(list(obj))),
+ 0x20: lambda ext: complex(*struct.unpack("ff", ext.data)),
+ 0x30: lambda ext: CustomType(*umsgpack.unpackb(ext.data)),
+}
+
+ext_handlers_test_vectors = [
+ [ "complex", complex(1, 2), b"\xd7\x20\x00\x00\x80\x3f\x00\x00\x00\x40" ],
+ [ "custom type", CustomType(b"abc", 123, True), b"\xd7\x30\x93\xc4\x03\x61\x62\x63\x7b\xc3" ],
+]
+
+# These are the only global variables that should be exported by umsgpack
+exported_vars_test_vector = [
+ "Ext",
+ "InvalidString",
+ "PackException",
+ "UnpackException",
+ "UnsupportedTypeException",
+ "InsufficientDataException",
+ "InvalidStringException",
+ "ReservedCodeException",
+ "UnhashableKeyException",
+ "DuplicateKeyException",
+ "KeyNotPrimitiveException",
+ "KeyDuplicateException",
+ "pack",
+ "packb",
+ "unpack",
+ "unpackb",
+ "dump",
+ "dumps",
+ "load",
+ "loads",
+ "version",
+ "compatibility",
+]
+
+################################################################################
+
+class TestUmsgpack(unittest.TestCase):
+ def test_pack_single(self):
+ for (name, obj, data) in single_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ self.assertEqual(umsgpack.packb(obj), data)
+
+ def test_pack_composite(self):
+ for (name, obj, data) in composite_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ self.assertEqual(umsgpack.packb(obj), data)
+
+ def test_pack_exceptions(self):
+ for (name, obj, exception) in pack_exception_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ with self.assertRaises(exception):
+ umsgpack.packb(obj)
+
+ def test_unpack_single(self):
+ for (name, obj, data) in single_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ unpacked = umsgpack.unpackb(data)
+
+ # In Python2, we have both int and long integer types, but which
+ # one we end up with depends on the architecture (32-bit/64-bit)
+ if sys.version_info[0] == 2:
+ # Allow both {int,long} -> unpackb -> {int,long}
+ if isinstance(obj, int) or isinstance(obj, long):
+ self.assertTrue(isinstance(unpacked, int) or isinstance(unpacked, long))
+ else:
+ self.assertTrue(isinstance(unpacked, type(obj)))
+ # In Python3, we only have the int integer type
+ else:
+ self.assertTrue(isinstance(unpacked, type(obj)))
+
+ self.assertEqual(unpacked, obj)
+
+ def test_unpack_composite(self):
+ for (name, obj, data) in composite_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ self.assertEqual(umsgpack.unpackb(data), obj)
+
+ def test_unpack_exceptions(self):
+ for (name, data, exception) in unpack_exception_test_vectors:
+ print("\tTesting %s" % name)
+ with self.assertRaises(exception):
+ umsgpack.unpackb(data)
+
+ def test_pack_compatibility(self):
+ umsgpack.compatibility = True
+
+ for (name, obj, data) in compatibility_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ self.assertEqual(umsgpack.packb(obj), data)
+
+ umsgpack.compatibility = False
+
+ def test_unpack_compatibility(self):
+ umsgpack.compatibility = True
+
+ for (name, obj, data) in compatibility_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ unpacked = umsgpack.unpackb(data)
+
+ # Encoded raw should always unpack to bytes in compatibility mode,
+ # so convert any string obj to bytes before comparison
+ if sys.version_info[0] == 3 and isinstance(obj, str):
+ _obj = obj.encode('utf-8')
+ elif sys.version_info[0] == 2 and isinstance(obj, unicode):
+ _obj = bytes(obj)
+ else:
+ _obj = obj
+
+ self.assertTrue(isinstance(unpacked, type(_obj)))
+ self.assertEqual(unpacked, _obj)
+
+ umsgpack.compatibility = False
+
+ def test_unpack_invalid_string(self):
+ # Use last unpack exception test vector (an invalid string)
+ (_, data, _) = unpack_exception_test_vectors[-1]
+
+ obj = umsgpack.unpackb(data, allow_invalid_utf8=True)
+ self.assertTrue(isinstance(obj, umsgpack.InvalidString))
+ self.assertEqual(obj, b"\x80")
+
+ def test_unpack_ordered_dict(self):
+ # Use last composite test vector (a map)
+ (_, obj, data) = composite_test_vectors[-1]
+
+ # Unpack with default options (unordered dict)
+ unpacked = umsgpack.unpackb(data)
+ self.assertTrue(isinstance(unpacked, dict))
+
+ # Unpack with unordered dict
+ unpacked = umsgpack.unpackb(data, use_ordered_dict=False)
+ self.assertTrue(isinstance(unpacked, dict))
+
+ # Unpack with ordered dict
+ unpacked = umsgpack.unpackb(data, use_ordered_dict=True)
+ self.assertTrue(isinstance(unpacked, OrderedDict))
+ self.assertEqual(unpacked, obj)
+
+ def test_ext_exceptions(self):
+ with self.assertRaises(TypeError):
+ _ = umsgpack.Ext(-1, b"")
+
+ with self.assertRaises(TypeError):
+ _ = umsgpack.Ext(128, b"")
+
+ with self.assertRaises(TypeError):
+ _ = umsgpack.Ext(0, u"unicode string")
+
+ def test_pack_ext_handler(self):
+ for (name, obj, data) in ext_handlers_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ self.assertEqual(umsgpack.packb(obj, ext_handlers=ext_handlers), data)
+
+ def test_unpack_ext_handler(self):
+ for (name, obj, data) in ext_handlers_test_vectors:
+ obj_repr = repr(obj)
+ print("\tTesting %s: object %s" % (name, obj_repr if len(obj_repr) < 24 else obj_repr[0:24] + "..."))
+ self.assertEqual(umsgpack.unpackb(data, ext_handlers=ext_handlers), obj)
+
+ def test_streaming_writer(self):
+ # Try first composite test vector
+ (_, obj, data) = composite_test_vectors[0]
+ writer = io.BytesIO()
+ umsgpack.pack(obj, writer)
+ self.assertTrue(writer.getvalue(), data)
+
+ def test_streaming_reader(self):
+ # Try first composite test vector
+ (_, obj, data) = composite_test_vectors[0]
+ reader = io.BytesIO(data)
+ self.assertEqual(umsgpack.unpack(reader), obj)
+
+ def test_namespacing(self):
+ # Get a list of global variables from umsgpack module
+ exported_vars = list(filter(lambda x: not x.startswith("_"), dir(umsgpack)))
+ # Ignore imports
+ exported_vars = list(filter(lambda x: x != "struct" and x != "collections" and x != "sys" and x != "io" and x != "xrange", exported_vars))
+
+ self.assertTrue(len(exported_vars) == len(exported_vars_test_vector))
+ for var in exported_vars_test_vector:
+ self.assertTrue(var in exported_vars)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/PKG-INFO b/u_msgpack_python.egg-info/PKG-INFO
similarity index 96%
copy from PKG-INFO
copy to u_msgpack_python.egg-info/PKG-INFO
index 67063be..1dfe610 100644
--- a/PKG-INFO
+++ b/u_msgpack_python.egg-info/PKG-INFO
@@ -1,10 +1,10 @@
Metadata-Version: 1.1
Name: u-msgpack-python
-Version: 2.1
+Version: 2.3.0
Summary: A portable, lightweight MessagePack serializer and deserializer written in pure Python.
Home-page: https://github.com/vsergeev/u-msgpack-python
Author: vsergeev
-Author-email: vsergeev at gmail
+Author-email: v at sergeev.io
License: MIT
Description: u-msgpack-python is a lightweight `MessagePack <http://msgpack.org/>`_ serializer and deserializer module written in pure Python, compatible with both Python 2 and Python 3, as well as CPython and PyPy implementations of Python. u-msgpack-python is fully compliant with the latest `MessagePack specification <https://github.com/msgpack/msgpack/blob/master/spec.md>`_. In particular, it supports the new binary, UTF-8 string, and application-defined ext types. See https://github. [...]
Keywords: msgpack serialization deserialization
diff --git a/u_msgpack_python.egg-info/SOURCES.txt b/u_msgpack_python.egg-info/SOURCES.txt
new file mode 100644
index 0000000..08e0ca2
--- /dev/null
+++ b/u_msgpack_python.egg-info/SOURCES.txt
@@ -0,0 +1,10 @@
+LICENSE
+MANIFEST.in
+setup.cfg
+setup.py
+test_umsgpack.py
+umsgpack.py
+u_msgpack_python.egg-info/PKG-INFO
+u_msgpack_python.egg-info/SOURCES.txt
+u_msgpack_python.egg-info/dependency_links.txt
+u_msgpack_python.egg-info/top_level.txt
\ No newline at end of file
diff --git a/u_msgpack_python.egg-info/dependency_links.txt b/u_msgpack_python.egg-info/dependency_links.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/u_msgpack_python.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/u_msgpack_python.egg-info/top_level.txt b/u_msgpack_python.egg-info/top_level.txt
new file mode 100644
index 0000000..9839e9f
--- /dev/null
+++ b/u_msgpack_python.egg-info/top_level.txt
@@ -0,0 +1 @@
+umsgpack
diff --git a/umsgpack.py b/umsgpack.py
index 4c2120c..c0647e0 100644
--- a/umsgpack.py
+++ b/umsgpack.py
@@ -1,4 +1,4 @@
-# u-msgpack-python v2.1 - vsergeev at gmail
+# u-msgpack-python v2.3.0 - v at sergeev.io
# https://github.com/vsergeev/u-msgpack-python
#
# u-msgpack-python is a lightweight MessagePack serializer and deserializer
@@ -10,7 +10,7 @@
#
# MIT License
#
-# Copyright (c) 2013-2014 Ivan A. Sergeev
+# Copyright (c) 2013-2016 vsergeev / Ivan (Vanya) A. Sergeev
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
@@ -31,7 +31,7 @@
# THE SOFTWARE.
#
"""
-u-msgpack-python v2.1 - vsergeev at gmail
+u-msgpack-python v2.3.0 - v at sergeev.io
https://github.com/vsergeev/u-msgpack-python
u-msgpack-python is a lightweight MessagePack serializer and deserializer
@@ -44,10 +44,10 @@ types.
License: MIT
"""
-__version__ = "2.1"
+__version__ = "2.3.0"
"Module version string"
-version = (2,1)
+version = (2,3,0)
"Module version tuple"
import struct
@@ -117,18 +117,16 @@ class Ext:
String representation of this Ext object.
"""
s = "Ext Object (Type: 0x%02x, Data: " % self.type
- for i in range(min(len(self.data), 8)):
- if i > 0:
- s += " "
- if isinstance(self.data[i], int):
- s += "%02x" % (self.data[i])
- else:
- s += "%02x" % ord(self.data[i])
+ s += " ".join(["0x%02x" % ord(self.data[i:i+1]) for i in xrange(min(len(self.data), 8))])
if len(self.data) > 8:
s += " ..."
s += ")"
return s
+class InvalidString(bytes):
+ """Subclass of bytes to hold invalid UTF-8 strings."""
+ pass
+
################################################################################
### Exceptions
################################################################################
@@ -148,7 +146,7 @@ class UnsupportedTypeException(PackException):
# Unpacking error
class InsufficientDataException(UnpackException):
- "Insufficient data to unpack the encoded object."
+ "Insufficient data to unpack the serialized object."
pass
class InvalidStringException(UnpackException):
"Invalid UTF-8 string encountered during unpacking."
@@ -212,7 +210,7 @@ b'\x92\xabsome string\xaasome bytes'
# chr(obj) has a str return type instead of bytes in Python 3, and
# struct.pack(...) has the right return type in both versions.
-def _pack_integer(obj, fp):
+def _pack_integer(obj, fp, options):
if obj < 0:
if obj >= -32:
fp.write(struct.pack("b", obj))
@@ -240,19 +238,19 @@ def _pack_integer(obj, fp):
else:
raise UnsupportedTypeException("huge unsigned int")
-def _pack_nil(obj, fp):
+def _pack_nil(obj, fp, options):
fp.write(b"\xc0")
-def _pack_boolean(obj, fp):
+def _pack_boolean(obj, fp, options):
fp.write(b"\xc3" if obj else b"\xc2")
-def _pack_float(obj, fp):
+def _pack_float(obj, fp, options):
if _float_size == 64:
fp.write(b"\xcb" + struct.pack(">d", obj))
else:
fp.write(b"\xca" + struct.pack(">f", obj))
-def _pack_string(obj, fp):
+def _pack_string(obj, fp, options):
obj = obj.encode('utf-8')
if len(obj) <= 31:
fp.write(struct.pack("B", 0xa0 | len(obj)) + obj)
@@ -265,7 +263,7 @@ def _pack_string(obj, fp):
else:
raise UnsupportedTypeException("huge string")
-def _pack_binary(obj, fp):
+def _pack_binary(obj, fp, options):
if len(obj) <= 2**8-1:
fp.write(b"\xc4" + struct.pack("B", len(obj)) + obj)
elif len(obj) <= 2**16-1:
@@ -275,7 +273,7 @@ def _pack_binary(obj, fp):
else:
raise UnsupportedTypeException("huge binary string")
-def _pack_oldspec_raw(obj, fp):
+def _pack_oldspec_raw(obj, fp, options):
if len(obj) <= 31:
fp.write(struct.pack("B", 0xa0 | len(obj)) + obj)
elif len(obj) <= 2**16-1:
@@ -285,7 +283,7 @@ def _pack_oldspec_raw(obj, fp):
else:
raise UnsupportedTypeException("huge raw string")
-def _pack_ext(obj, fp):
+def _pack_ext(obj, fp, options):
if len(obj.data) == 1:
fp.write(b"\xd4" + struct.pack("B", obj.type & 0xff) + obj.data)
elif len(obj.data) == 2:
@@ -305,7 +303,7 @@ def _pack_ext(obj, fp):
else:
raise UnsupportedTypeException("huge ext data")
-def _pack_array(obj, fp):
+def _pack_array(obj, fp, options):
if len(obj) <= 15:
fp.write(struct.pack("B", 0x90 | len(obj)))
elif len(obj) <= 2**16-1:
@@ -316,9 +314,9 @@ def _pack_array(obj, fp):
raise UnsupportedTypeException("huge array")
for e in obj:
- pack(e, fp)
+ pack(e, fp, **options)
-def _pack_map(obj, fp):
+def _pack_map(obj, fp, options):
if len(obj) <= 15:
fp.write(struct.pack("B", 0x80 | len(obj)))
elif len(obj) <= 2**16-1:
@@ -329,13 +327,13 @@ def _pack_map(obj, fp):
raise UnsupportedTypeException("huge array")
for k,v in obj.items():
- pack(k, fp)
- pack(v, fp)
+ pack(k, fp, **options)
+ pack(v, fp, **options)
########################################
# Pack for Python 2, with 'unicode' type, 'str' type, and 'long' type
-def _pack2(obj, fp):
+def _pack2(obj, fp, **options):
"""
Serialize a Python object into MessagePack bytes.
@@ -343,6 +341,11 @@ def _pack2(obj, fp):
obj: a Python object
fp: a .write()-supporting file-like object
+ Kwargs:
+ ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
+ to a callable that packs an instance of the type
+ into an Ext object
+
Returns:
None.
@@ -351,40 +354,50 @@ def _pack2(obj, fp):
Object type not supported for packing.
Example:
- >>> f = open('test.bin', 'w')
+ >>> f = open('test.bin', 'wb')
>>> umsgpack.pack({u"compact": True, u"schema": 0}, f)
>>>
"""
-
global compatibility
+ ext_handlers = options.get("ext_handlers")
+
if obj is None:
- _pack_nil(obj, fp)
+ _pack_nil(obj, fp, options)
+ elif ext_handlers and obj.__class__ in ext_handlers:
+ _pack_ext(ext_handlers[obj.__class__](obj), fp, options)
elif isinstance(obj, bool):
- _pack_boolean(obj, fp)
+ _pack_boolean(obj, fp, options)
elif isinstance(obj, int) or isinstance(obj, long):
- _pack_integer(obj, fp)
+ _pack_integer(obj, fp, options)
elif isinstance(obj, float):
- _pack_float(obj, fp)
+ _pack_float(obj, fp, options)
elif compatibility and isinstance(obj, unicode):
- _pack_oldspec_raw(bytes(obj), fp)
+ _pack_oldspec_raw(bytes(obj), fp, options)
elif compatibility and isinstance(obj, bytes):
- _pack_oldspec_raw(obj, fp)
+ _pack_oldspec_raw(obj, fp, options)
elif isinstance(obj, unicode):
- _pack_string(obj, fp)
+ _pack_string(obj, fp, options)
elif isinstance(obj, str):
- _pack_binary(obj, fp)
+ _pack_binary(obj, fp, options)
elif isinstance(obj, list) or isinstance(obj, tuple):
- _pack_array(obj, fp)
+ _pack_array(obj, fp, options)
elif isinstance(obj, dict):
- _pack_map(obj, fp)
+ _pack_map(obj, fp, options)
elif isinstance(obj, Ext):
- _pack_ext(obj, fp)
+ _pack_ext(obj, fp, options)
+ elif ext_handlers:
+ # Linear search for superclass
+ t = next((t for t in ext_handlers.keys() if isinstance(obj, t)), None)
+ if t:
+ _pack_ext(ext_handlers[t](obj), fp, options)
+ else:
+ raise UnsupportedTypeException("unsupported type: %s" % str(type(obj)))
else:
raise UnsupportedTypeException("unsupported type: %s" % str(type(obj)))
# Pack for Python 3, with unicode 'str' type, 'bytes' type, and no 'long' type
-def _pack3(obj, fp):
+def _pack3(obj, fp, **options):
"""
Serialize a Python object into MessagePack bytes.
@@ -392,6 +405,11 @@ def _pack3(obj, fp):
obj: a Python object
fp: a .write()-supporting file-like object
+ Kwargs:
+ ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
+ to a callable that packs an instance of the type
+ into an Ext object
+
Returns:
None.
@@ -400,44 +418,60 @@ def _pack3(obj, fp):
Object type not supported for packing.
Example:
- >>> f = open('test.bin', 'w')
- >>> umsgpack.pack({u"compact": True, u"schema": 0}, fp)
+ >>> f = open('test.bin', 'wb')
+ >>> umsgpack.pack({u"compact": True, u"schema": 0}, f)
>>>
"""
global compatibility
+ ext_handlers = options.get("ext_handlers")
+
if obj is None:
- _pack_nil(obj, fp)
+ _pack_nil(obj, fp, options)
+ elif ext_handlers and obj.__class__ in ext_handlers:
+ _pack_ext(ext_handlers[obj.__class__](obj), fp, options)
elif isinstance(obj, bool):
- _pack_boolean(obj, fp)
+ _pack_boolean(obj, fp, options)
elif isinstance(obj, int):
- _pack_integer(obj, fp)
+ _pack_integer(obj, fp, options)
elif isinstance(obj, float):
- _pack_float(obj, fp)
+ _pack_float(obj, fp, options)
elif compatibility and isinstance(obj, str):
- _pack_oldspec_raw(obj.encode('utf-8'), fp)
+ _pack_oldspec_raw(obj.encode('utf-8'), fp, options)
elif compatibility and isinstance(obj, bytes):
- _pack_oldspec_raw(obj, fp)
+ _pack_oldspec_raw(obj, fp, options)
elif isinstance(obj, str):
- _pack_string(obj, fp)
+ _pack_string(obj, fp, options)
elif isinstance(obj, bytes):
- _pack_binary(obj, fp)
+ _pack_binary(obj, fp, options)
elif isinstance(obj, list) or isinstance(obj, tuple):
- _pack_array(obj, fp)
+ _pack_array(obj, fp, options)
elif isinstance(obj, dict):
- _pack_map(obj, fp)
+ _pack_map(obj, fp, options)
elif isinstance(obj, Ext):
- _pack_ext(obj, fp)
+ _pack_ext(obj, fp, options)
+ elif ext_handlers:
+ # Linear search for superclass
+ t = next((t for t in ext_handlers.keys() if isinstance(obj, t)), None)
+ if t:
+ _pack_ext(ext_handlers[t](obj), fp, options)
+ else:
+ raise UnsupportedTypeException("unsupported type: %s" % str(type(obj)))
else:
raise UnsupportedTypeException("unsupported type: %s" % str(type(obj)))
-def _packb2(obj):
+def _packb2(obj, **options):
"""
Serialize a Python object into MessagePack bytes.
Args:
obj: a Python object
+ Kwargs:
+ ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
+ to a callable that packs an instance of the type
+ into an Ext object
+
Returns:
A 'str' containing serialized MessagePack bytes.
@@ -451,16 +485,21 @@ def _packb2(obj):
>>>
"""
fp = io.BytesIO()
- _pack2(obj, fp)
+ _pack2(obj, fp, **options)
return fp.getvalue()
-def _packb3(obj):
+def _packb3(obj, **options):
"""
Serialize a Python object into MessagePack bytes.
Args:
obj: a Python object
+ Kwargs:
+ ext_handlers (dict): dictionary of Ext handlers, mapping a custom type
+ to a callable that packs an instance of the type
+ into an Ext object
+
Returns:
A 'bytes' containing serialized MessagePack bytes.
@@ -474,7 +513,7 @@ def _packb3(obj):
>>>
"""
fp = io.BytesIO()
- _pack3(obj, fp)
+ _pack3(obj, fp, **options)
return fp.getvalue()
################################################################################
@@ -487,7 +526,7 @@ def _read_except(fp, n):
raise InsufficientDataException()
return data
-def _unpack_integer(code, fp):
+def _unpack_integer(code, fp, options):
if (ord(code) & 0xe0) == 0xe0:
return struct.unpack("b", code)[0]
elif code == b'\xd0':
@@ -510,31 +549,31 @@ def _unpack_integer(code, fp):
return struct.unpack(">Q", _read_except(fp, 8))[0]
raise Exception("logic error, not int: 0x%02x" % ord(code))
-def _unpack_reserved(code, fp):
+def _unpack_reserved(code, fp, options):
if code == b'\xc1':
raise ReservedCodeException("encountered reserved code: 0x%02x" % ord(code))
raise Exception("logic error, not reserved code: 0x%02x" % ord(code))
-def _unpack_nil(code, fp):
+def _unpack_nil(code, fp, options):
if code == b'\xc0':
return None
raise Exception("logic error, not nil: 0x%02x" % ord(code))
-def _unpack_boolean(code, fp):
+def _unpack_boolean(code, fp, options):
if code == b'\xc2':
return False
elif code == b'\xc3':
return True
raise Exception("logic error, not boolean: 0x%02x" % ord(code))
-def _unpack_float(code, fp):
+def _unpack_float(code, fp, options):
if code == b'\xca':
return struct.unpack(">f", _read_except(fp, 4))[0]
elif code == b'\xcb':
... 279 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/u-msgpack-python.git
More information about the Python-modules-commits
mailing list