Pass options to unpackb static method.

Author: peterhinch

README.md

@@ -10,7 +10,7 @@
 
 from sys import platform
 import asyncio
-import umsgpack
+import umsgpack, umsgpack.mpk_complex
 from machine import UART, Pin
 import gc
 
@@ -32,7 +32,8 @@ async def sender():
         True,
         False,
         0xFFFFFFFF,
-        {"foo": b"\x80\x01\x02", "bar": [1, 2, 3, {"a": [1, 2, 3, {}]}]},
+        1 + 1j,
+        {"foox": b"\x80\x01\x02", "bar": [1, 2, 3, {"a": [1, 2, 3, {}]}], (1, (2, 3)): 42},
         -1,
         2.12345,
     ]
@@ -56,7 +57,7 @@ def __call__(self, data: bytes) -> None:
 
 
 async def receiver():
-    uart_aloader = umsgpack.aloader(asyncio.StreamReader(uart), observer=StreamObserver())
+    uart_aloader = umsgpack.ALoader(asyncio.StreamReader(uart), observer=StreamObserver())
     async for res in uart_aloader:
         print("Received (aloader):", res)
 

asyntest.py

@@ -2,15 +2,23 @@
 
 # Configured for pyserial. Link RX and TX pins.
 
-# Copyright (c) 2024 Peter Hinch Released under the MIT License see LICENSE
+# Copyright (c) 2024-2025 Peter Hinch Released under the MIT License see LICENSE
 
 import asyncio
 import umsgpack
 import serial_asyncio
 
+
 async def sender(swriter):
-    obj = [1, True, False, 0xffffffff, {u"foo": b"\x80\x01\x02", \
-                  u"bar": [1,2,3, {u"a": [1,2,3,{}]}]}, -1, 2.12345]
+    obj = [
+        1,
+        True,
+        False,
+        0xFFFFFFFF,
+        {"foo": b"\x80\x01\x02", "bar": [1, 2, 3, {"a": [1, 2, 3, {}]}]},
+        -1,
+        2.12345,
+    ]
 
     while True:
         s = umsgpack.dumps(obj)
@@ -19,35 +27,41 @@ async def sender(swriter):
         await asyncio.sleep(5)
         obj[0] += 1
 
+
 class stream_observer:
     def update(self, data: bytes) -> None:
-        print(f'{data}')
+        print(f"{data}")
+
 
 async def receiver(sreader):
     recv_observer = stream_observer()
     while True:
         res = await umsgpack.aload(sreader, observer=recv_observer)
-        print('Received:', res)
+        print("Received:", res)
+
 
 async def receiver_using_aloader(sreader):
     uart_aloader = umsgpack.aloader(sreader, observer=stream_observer())
     while True:
         res = await uart_aloader.load()
-        print('Received (aloader):', res)
+        print("Received (aloader):", res)
+
 
 async def main():
-    reader, writer = await serial_asyncio.open_serial_connection(url='/dev/ttyUSB0', baudrate=9600)
+    reader, writer = await serial_asyncio.open_serial_connection(url="/dev/ttyUSB0", baudrate=9600)
     asyncio.create_task(sender(writer))
     # asyncio.create_task(receiver(reader))
     asyncio.create_task(receiver_using_aloader(reader))
     while True:
-        print('running...')
+        print("running...")
         await asyncio.sleep(20)
 
+
 def test():
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        print('Interrupted')
+        print("Interrupted")
+
 
 test()

asyntest_py3_serial.py

@@ -1,11 +1,13 @@
 {
   "urls": [
     ["umsgpack/__init__.py", "github:peterhinch/micropython-msgpack/umsgpack/__init__.py"],
-    ["umsgpack/as_load.py", "github:peterhinch/micropython-msgpack/umsgpack/as_load.py"],
     ["umsgpack/as_loader.py", "github:peterhinch/micropython-msgpack/umsgpack/as_loader.py"],
     ["umsgpack/mp_dump.py", "github:peterhinch/micropython-msgpack/umsgpack/mp_dump.py"],
     ["umsgpack/mp_load.py", "github:peterhinch/micropython-msgpack/umsgpack/mp_load.py"],
-    ["umsgpack/umsgpack_ext.py", "github:peterhinch/micropython-msgpack/umsgpack/umsgpack_ext.py"],
+    ["umsgpack/mpk_bytearray.py", "github:peterhinch/micropython-msgpack/umsgpack/mpk_bytearray.py"],
+    ["umsgpack/mpk_complex.py", "github:peterhinch/micropython-msgpack/umsgpack/mpk_complex.py"],
+    ["umsgpack/mpk_set.py", "github:peterhinch/micropython-msgpack/umsgpack/mpk_set.py"],
+    ["umsgpack/mpk_tuple.py", "github:peterhinch/micropython-msgpack/umsgpack/mpk_tuple.py"],
     ["asyntest.py", "github:peterhinch/micropython-msgpack/asyntest.py"],
     ["user_class.py", "github:peterhinch/micropython-msgpack/user_class.py"]
   ],

package.json

@@ -290,30 +290,31 @@
     ],
 ]
 
-
+# Dynamic loader prevents this test from working
 # These are the only global variables that should be exported by umsgpack
-exported_vars_test_vector = [
-    "dump",
-    "dumps",
-    "load",
-    "loads",
-    "aloader",
-    "Packer",
-    "custom",
-    "ext_type_to_class",
-    "types",
-    "ext_serializable",
-    "PackException",
-    "UnpackException",
-    "UnsupportedTypeException",
-    "InsufficientDataException",
-    "InvalidStringException",
-    "ReservedCodeException",
-    "UnhashableKeyException",
-    "DuplicateKeyException",
-    "aload",
-    "aloader",
-]
+# exported_vars_test_vector = [
+#     "dump",
+#     "dumps",
+#     "load",
+#     "loads",
+#     "Packer",
+#     "custom",
+#     "ext_type_to_class",
+#     "types",
+#     "ext_serializable",
+#     "PackException",
+#     "UnpackException",
+#     "UnsupportedTypeException",
+#     "InsufficientDataException",
+#     "InvalidStringException",
+#     "ReservedCodeException",
+#     "UnhashableKeyException",
+#     "DuplicateKeyException",
+#     "mp_load",
+#     "mp_dump",
+#     "ALoader",
+#     "as_loader",
+# ]
 
 ##########################################################################
 
@@ -456,7 +457,7 @@ def packb(self):
                 return struct.pack("<II", self.real, self.imag)
 
             @classmethod
-            def unpackb(cls, data):
+            def unpackb(cls, data, options):
                 return cls(*struct.unpack("<II", data))
 
         obj, data = CustomComplex(123, 456), b"\xd7\x20\x7b\x00\x00\x00\xc8\x01\x00\x00"
@@ -516,7 +517,7 @@ def packb(self):  # Must change to list otherwise get infinite recursion
                 return umsgpack.dumps(list(self.s))
 
             @staticmethod
-            def unpackb(data):
+            def unpackb(data, options):
                 return set(umsgpack.loads(data))
 
         packed = umsgpack.dumps({1, 2, 3})
@@ -542,7 +543,7 @@ def packb(self):
                 return umsgpack.dumps([self.length, self.width])
 
             @classmethod
-            def unpackb(cls, data):
+            def unpackb(cls, data, options):
                 return cls(*umsgpack.loads(data))
 
         class Square(Rectangle):
@@ -575,15 +576,16 @@ def test_streaming_reader(self):
         reader = io.BytesIO(data)
         self.assertEqual(umsgpack.load(reader), obj)
 
-    def test_namespacing(self):
-        # Get a list of global variables from umsgpack module
-        exported_vars = list([x for x in dir(umsgpack) if not x.startswith("_")])
-
-        self.assertEqual(len(exported_vars), len(exported_vars_test_vector))
-        print("###")
-        print("Test namespace")
-        for var in exported_vars_test_vector:
-            self.assertTrue(var in exported_vars)
+    # Dynamic loader prevents this test from working
+    # def test_namespacing(self):
+    #     # Get a list of global variables from umsgpack module
+    #     exported_vars = list([x for x in dir(umsgpack) if not x.startswith("_")])
+    #
+    #     self.assertEqual(len(exported_vars), len(exported_vars_test_vector))
+    #     print("###")
+    #     print("Test namespace")
+    #     for var in exported_vars_test_vector:
+    #         self.assertTrue(var in exported_vars)
 
     def test_load_short_read(self):
         # When reading from files, the network, etc. there's no guarantee that

run_test_suite

@@ -24,7 +24,7 @@
 # Method of detecting platform's float size changed.
 # Version reset to (0.1.0).
 
-__version__ = (0, 1, 3)
+__version__ = (0, 2, 0)
 
 # ABC for classes which handle extended Python built-in classes.
 class Packer:
@@ -41,9 +41,15 @@ def __call__(self, obj):
 # Ext Serializable Decorator
 ##############################################################################
 
-custom = {}  # Pack. Key: Custom class. Value: ext_type integer.
-ext_type_to_class = {}  # Unpack. Key: ext_type integer Value: Packer subclass.
-types = {}  # Pack. Key: data type to pack Value: ext_type integer.
+# Global dicts
+# Packer
+custom = {}  # Pack custom. Key: Custom class. Value: ext_type integer.
+builtins = {}  # Pack built-in. Key: data type to pack
+# Value: (ext_type byte, Packer class).
+# The second item is replaced with Packer instance once one exists.
+
+# Unpacker
+packers = {}  # Key: ext_type integer Value: Packer subclass.
 
 # Decorator. Args:
 # ext_type: An integer identifying the packed record.
@@ -55,99 +61,82 @@ def wrapper(cls):
             raise TypeError("Ext type is not type integer")
         elif not (-128 <= ext_type <= 127):
             raise ValueError("Ext type value {:d} is out of range of -128 to 127".format(ext_type))
-        elif ext_type in ext_type_to_class:
+        elif ext_type in packers:
             raise ValueError(
                 "Ext type {:d} already registered with class {:s}".format(
-                    ext_type, repr(ext_type_to_class[ext_type])
+                    ext_type, repr(packers[ext_type])
                 )
             )
         elif cls in custom:
             raise ValueError(
                 "Class {:s} already registered with Ext type {:d}".format(repr(cls), ext_type)
             )
 
-        ext_type_to_class[ext_type] = cls  # For unpack
+        packers[ext_type] = cls  # For unpack
         if example is None:  # Custom class
             custom[cls] = ext_type
         else:  # Extension type having a Packer class
-            types[example] = (cls, ext_type)
+            builtins[example] = (cls, ext_type)
         return cls
 
     return wrapper
 
 
-##############################################################################
 # Exceptions
-##############################################################################
 
 # Base Exception classes
 class PackException(Exception):
-    "Base class for exceptions encountered during packing."
+    pass
 
 
 class UnpackException(Exception):
-    "Base class for exceptions encountered during unpacking."
+    pass
 
 
 # Packing error
 class UnsupportedTypeException(PackException):
-    "Object type not supported for packing."
+    pass
 
 
 # Unpacking error
 class InsufficientDataException(UnpackException):
-    "Insufficient data to unpack the serialized object."
+    pass
 
 
 class InvalidStringException(UnpackException):
-    "Invalid UTF-8 string encountered during unpacking."
+    pass
 
 
 class ReservedCodeException(UnpackException):
-    "Reserved code encountered during unpacking."
+    pass
 
 
 class UnhashableKeyException(UnpackException):
-    """
-    Unhashable key encountered during map unpacking.
-    The serialized map cannot be deserialized into a Python dictionary.
-    """
+    pass
 
 
 class DuplicateKeyException(UnpackException):
-    "Duplicate key encountered during map unpacking."
-
-
-##############################################################################
-# Lazy module load to save RAM: takes about 20μs on Pyboard 1.x after initial load
-##############################################################################
-
-
-def load(fp, **options):
-    from . import mp_load
-
-    return mp_load.mpload(fp, options)
-
-
-def loads(s, **options):
-    from . import mp_load
-
-    return mp_load.mploads(s, options)
-
-
-def dump(obj, fp, **options):
-    from . import mp_dump
-
-    mp_dump.mpdump(obj, fp, options)
-
-
-def dumps(obj, **options):
-    from . import mp_dump
-
-    return mp_dump.mpdumps(obj, options)
-
-
-def aloader(fp, **options):
-    from . import as_loader
-
-    return as_loader.asloader(fp, options)
+    pass
+
+
+# Lazy loader
+
+_attrs = {
+    "load": "mp_load",
+    "loads": "mp_load",
+    "dump": "mp_dump",
+    "dumps": "mp_dump",
+    "ALoader": "as_loader",
+}
+
+# Copied from asyncio.__init__.py
+# Lazy loader, effectively does:
+#   global attr
+#   from .mod import attr
+def __getattr__(attr):
+    mod = _attrs.get(attr, None)
+    if mod is None:
+        raise AttributeError(attr)
+    value = getattr(__import__(mod, globals(), None, True, 1), attr)
+    globals()[attr] = value
+    return value