adding STRUCT_MAPPING constant

Author: crazyeng

wolframclient/deserializers/wxf/wxfparser.py

@@ -141,27 +141,27 @@ def token_for_string(self, token):
 
     def token_for_integer8(self, token):
         self.context.add_part()
-        token.data = constants.StructInt8LE.unpack(self.reader.read(1))[0]
+        token.data = constants.STRUCT_MAPPING.Integer8.unpack(self.reader.read(1))[0]
         return token
 
     def token_for_integer16(self, token):
         self.context.add_part()
-        token.data = constants.StructInt16LE.unpack(self.reader.read(2))[0]
+        token.data = constants.STRUCT_MAPPING.Integer16.unpack(self.reader.read(2))[0]
         return token
 
     def token_for_integer32(self, token):
         self.context.add_part()
-        token.data = constants.StructInt32LE.unpack(self.reader.read(4))[0]
+        token.data = constants.STRUCT_MAPPING.Integer32.unpack(self.reader.read(4))[0]
         return token
 
     def token_for_integer64(self, token):
         self.context.add_part()
-        token.data = constants.StructInt64LE.unpack(self.reader.read(8))[0]
+        token.data = constants.STRUCT_MAPPING.Integer64.unpack(self.reader.read(8))[0]
         return token
 
     def token_for_real64(self, token):
         self.context.add_part()
-        token.data = constants.StructDouble.unpack(self.reader.read(8))[0]
+        token.data = constants.STRUCT_MAPPING.Real64.unpack(self.reader.read(8))[0]
         return token
 
     def token_for_function(self, token):

wolframclient/serializers/wxfencoder/constants.py

@@ -91,13 +91,17 @@ def _bytes(value):
     )
 )
 
-StructInt8LE = struct.Struct(b"<b")
-StructUInt8LE = struct.Struct(b"<B")
-StructInt16LE = struct.Struct(b"<h")
-StructUInt16LE = struct.Struct(b"<H")
-StructInt32LE = struct.Struct(b"<i")
-StructUInt32LE = struct.Struct(b"<I")
-StructInt64LE = struct.Struct(b"<q")
-StructUInt64LE = struct.Struct(b"<Q")
-StructFloat = struct.Struct(b"<f")
-StructDouble = struct.Struct(b"<d")
+STRUCT_MAPPING = Settings(
+    Integer8=struct.Struct(b"<b"),
+    UnsignedInteger8=struct.Struct(b"<B"),
+    Integer16=struct.Struct(b"<h"),
+    UnsignedInteger16=struct.Struct(b"<H"),
+    Integer32=struct.Struct(b"<i"),
+    UnsignedInteger32=struct.Struct(b"<I"),
+    Integer64=struct.Struct(b"<q"),
+    UnsignedInteger64=struct.Struct(b"<Q"),
+    Real32=struct.Struct(b"<f"),
+    Real64=struct.Struct(b"<d"),
+    ComplexReal32=struct.Struct(b"<f"),
+    ComplexReal64=struct.Struct(b"<d"),
+)

wolframclient/serializers/wxfencoder/utils.py

@@ -3,18 +3,9 @@
 from wolframclient.exception import WolframLanguageException
 from wolframclient.serializers.wxfencoder.constants import (
     ARRAY_TYPES,
+    STRUCT_MAPPING,
     VALID_PACKED_ARRAY_TYPES,
     WXF_CONSTANTS,
-    StructDouble,
-    StructFloat,
-    StructInt8LE,
-    StructInt16LE,
-    StructInt32LE,
-    StructInt64LE,
-    StructUInt8LE,
-    StructUInt16LE,
-    StructUInt32LE,
-    StructUInt64LE,
 )
 from wolframclient.utils import six
 from wolframclient.utils.datastructures import Settings
@@ -71,7 +62,12 @@ def integer_size(value):
         raise ValueError("Value %i is not a machine-sized integer." % value)
 
 
-_packing = {1: StructInt8LE, 2: StructInt16LE, 4: StructInt32LE, 8: StructInt64LE}
+_packing = {
+    1: STRUCT_MAPPING.Integer8,
+    2: STRUCT_MAPPING.Integer16,
+    4: STRUCT_MAPPING.Integer32,
+    8: STRUCT_MAPPING.Integer64,
+}
 
 if six.JYTHON:
 
@@ -97,17 +93,17 @@ def integer_to_bytes(value, int_size):
 
 if six.JYTHON:
 
-    def float_to_bytes(value):
+    def float_to_bytes(value, pack_into=STRUCT_MAPPING.Real64.pack_into):
         buffer = jarray.zeros(8, "c")
-        StructDouble.pack_into(buffer, 0, value)
+        pack_into(buffer, 0, value)
         return buffer.tostring()
 
 
 else:
 
-    def float_to_bytes(value):
+    def float_to_bytes(value, pack_into=STRUCT_MAPPING.Real64.pack_into):
         buffer = bytearray(8)
-        StructDouble.pack_into(buffer, 0, value)
+        pack_into(buffer, 0, value)
         return buffer
 
 
@@ -146,20 +142,7 @@ def array_to_list(data, dimensions, wl_type):
 
 
 if hasattr(memoryview, "cast"):
-    unpack_mapping = Settings(
-        Integer8="b",
-        UnsignedInteger8="B",
-        Integer16="h",
-        UnsignedInteger16="H",
-        Integer32="i",
-        UnsignedInteger32="I",
-        Integer64="q",
-        UnsignedInteger64="Q",
-        Real32="f",
-        Real64="d",
-        ComplexReal32="f",
-        ComplexReal64="d",
-    )
+    unpack_mapping = Settings((k, v.format[1:]) for k, v in STRUCT_MAPPING.items())
 
     def _to_complex(array, max_depth, curr_depth):
         # recursivelly traverse the array until the last (real) dimension is reached
@@ -188,20 +171,6 @@ def _array_to_list(data, shape, array_type):
 
 
 else:
-    unpack_mapping = Settings(
-        Integer8=StructInt8LE,
-        UnsignedInteger8=StructUInt8LE,
-        Integer16=StructInt16LE,
-        UnsignedInteger16=StructUInt16LE,
-        Integer32=StructInt32LE,
-        UnsignedInteger32=StructUInt32LE,
-        Integer64=StructInt64LE,
-        UnsignedInteger64=StructUInt64LE,
-        Real32=StructFloat,
-        Real64=StructDouble,
-        ComplexReal32=StructFloat,
-        ComplexReal64=StructDouble,
-    )
 
     def _array_to_list(data, shape, array_type):
         value, _ = _build_array_from_bytes(data, 0, array_type, shape, 0)
@@ -216,7 +185,7 @@ def _build_array_from_bytes(data, offset, array_type, dimensions, current_dim):
                 )
                 new_array.append(new_elem)
         else:
-            struct = unpack_mapping[array_type]
+            struct = STRUCT_MAPPING[array_type]
             # complex values, need two reals for each.
             if array_type == "ComplexReal32" or array_type == "ComplexReal64":
                 for i in range(dimensions[-1]):