Fix: APD/EmptyData deserialization

python/MDSplus/apd.py

@@ -79,10 +79,7 @@ def _descriptor(self):
 
     @classmethod
     def fromDescriptor(cls, d):
-        num = d.arsize//d.length
-        dptrs = _C.cast(d.pointer, _C.POINTER(_C.c_void_p*num)).contents
-        descs = [_dsc.pointerToObject(dptr, d.tree) for dptr in dptrs]
-        return cls(descs)._setTree(d.tree)
+        return cls([dptr.value for dptr in d.descriptors])._setTree(d.tree)
 
     def __init__(self, value=None, dtype=0):
         """Initializes a Apd instance
@@ -231,9 +228,6 @@ def _descs(self): return self
 
 
 descriptor = _mimport('descriptor')
-descriptor.dtypeToClass[Apd.dtype_id] = Apd
-descriptor.dtypeToClass[List.dtype_id] = List
-descriptor.dtypeToClass[Dictionary.dtype_id] = Dictionary
 descriptor.dtypeToArrayClass[Apd.dtype_id] = Apd
 descriptor.dtypeToArrayClass[List.dtype_id] = List
 descriptor.dtypeToArrayClass[Dictionary.dtype_id] = Dictionary

python/MDSplus/descriptor.py

@@ -133,15 +133,25 @@ def __init__(self, obj_in=None, _dict_={}):
         self.ptr = _C.pointer(self._structure)
         self.ptr_ = _C.cast(self.ptr, Descriptor.PTR)
 
-    def __getattr__(self, name):
-        if name != '_structure' and name in dict(self._structure._fields_):
-            return self._structure.__getattribute__(name)
-        return super(Descriptor, self).__getattr__(name)
+    @property
+    def length(self): return self._structure.length
+    @length.setter
+    def length(self, value): self._structure.length = value
 
-    def __setattr__(self, name, value):
-        if name != '_structure' and name in dict(self._structure._fields_):
-            return self._structure.__setattr__(name, value)
-        return super(Descriptor, self).__setattr__(name, value)
+    @property
+    def dclass(self): return self._structure.dclass
+    @dclass.setter
+    def dclass(self, value): self._structure.dclass = value
+
+    @property
+    def dtype(self): return self._structure.dtype
+    @dtype.setter
+    def dtype(self, value): self._structure.dtype = value
+
+    @property
+    def pointer(self): return self._structure.pointer
+    @pointer.setter
+    def pointer(self, value): self._structure.pointer = value
 
     @property
     def addressof(self):
@@ -192,9 +202,19 @@ def _new_structure(self, l_length=0, **kwarg):
     null = _C.cast(0, PTR)
 
     @property
-    def value(self):
+    def descriptor(self):
         if self.l_length and self.pointer:
-            return Descriptor(self.pointer, self.__dict__)._setTree(self.tree).value
+            return Descriptor(self.pointer, self.__dict__)._setTree(self.tree)
+        return DescriptorNULL
+
+    @property
+    def value(self):
+        return self.descriptor.value
+
+    @property
+    def l_length(self): return self._structure.l_length
+    @l_length.setter
+    def l_length(self, value): self._structure.l_length = value
 
 
 class DescriptorXD(DescriptorXS):
@@ -216,6 +236,16 @@ class _structure_class(_C.Structure):
     PTR = _C.POINTER(_structure_class)
     null = _C.cast(0, PTR)
 
+    @property
+    def ndesc(self): return self._structure.ndesc
+    @ndesc.setter
+    def ndesc(self, value): self._structure.ndesc = value
+
+    @property
+    def dscptrs(self): return self._structure.dscptrs
+    @dscptrs.setter
+    def dscptrs(self, value): self._structure.dscptrs = value
+
 # HINT: arrays
 
 
@@ -301,6 +331,45 @@ def bounds(self, value):
         else:
             self.aflags &= ~128
 
+    @property
+    def scale(self): return self._structure.scale
+    @scale.setter
+    def scale(self, value): self._structure.scale = value
+
+    @property
+    def digits(self): return self._structure.digits
+    @digits.setter
+    def digits(self, value): self._structure.digits = value
+
+    @property
+    def aflags(self): return self._structure.aflags
+    @aflags.setter
+    def aflags(self, value): self._structure.aflags = value
+
+    @property
+    def dimct(self): return self._structure.dimct
+    @dimct.setter
+    def dimct(self, value): self._structure.dimct = value
+
+    @property
+    def arsize(self): return self._structure.arsize
+    @arsize.setter
+    def arsize(self, value): self._structure.arsize = value
+
+    @property
+    def a0(self): return self._structure.a0
+    @a0.setter
+    def a0(self, value): self._structure.a0 = value
+
+    @property
+    def coeff_and_bounds(self): return self._structure.coeff_and_bounds
+    @coeff_and_bounds.setter
+    def coeff_and_bounds(self, value): self._structure.coeff_and_bounds = value
+
+    @property
+    def size(self):
+        return self._structure.arsize // self._structure.length
+
 
 class DescriptorCA(DescriptorA):
     dclass_id = 195
@@ -315,6 +384,12 @@ def value(self):
 class DescriptorAPD(DescriptorA):
     dclass_id = 196
 
+    @property
+    def descriptors(self):
+        tree = self.tree
+        dptrs = _C.cast(self.pointer, _C.POINTER(_C.c_void_p*self.size)).contents
+        return [Descriptor(dptr)._setTree(tree) for dptr in dptrs]
+
 
 dclassToClass = {DescriptorS.dclass_id: DescriptorS,
                  DescriptorD.dclass_id: DescriptorD,

python/MDSplus/tests/data_case.py

@@ -42,6 +42,7 @@ class Tests(_common.Tests):
     TESTS = {
         'data', 'scalars', 'arrays', 'vms',
         'tdi', 'decompile', 'casts', 'tdipy',
+        'deserialize',
     }
 
     def _doThreeTest(self, tdiexpr, pyexpr, ans, **kwargs):
@@ -437,6 +438,11 @@ def decompile(self):
         self.assertEqual(str(m.Signal(m.ZERO(100000, 0.).evaluate(
         ), None, 0.)), "Build_Signal(Set_Range(100000,0D0 /*** etc. ***/), *, 0D0)")
 
+    def deserialize(self):
+        d = m.Dictionary((1, m.EmptyData))
+        s = d.serialize()
+        self.assertEqual(m.EmptyData, s.deserialize()[1])
+
     def casts(self):
         for WITH in (m.WithError, m.Parameter, m.WithUnits):
             data = WITH(1, "with")