Changeset 1221 for trunk/bindings/python/nxs

Timestamp:

08/04/09 01:07:17 (3 years ago)

Author:

Paul Kienzle

Message:

fix python string issue. Refs #173.

File:

• trunk/bindings/python/nxs/napi.py (modified) (22 diffs)

trunk/bindings/python/nxs/napi.py

@@ -419 +419 @@
         Corresponds to NXmakegroup(handle, name, nxclass)
         """
+        #print "makegroup",self._loc(),name,nxclass
         status = nxlib.nximakegroup_(self.handle, name, nxclass)
         if status == ERROR:
@@ -556 +557 @@
         Corresponds to NXopengroup(handle, name, nxclass)
         """
-        #print "open group",nxclass,name
+        #print "opengroup",self._loc(),name,nxclass
         if nxclass is None:
             nxclass = self.__getnxclass(name)
@@ -575 +576 @@
         Corresponds to NXclosegroup(handle)
         """
-        #print "close group"
+        #print "closegroup"
         status = nxlib.nxiclosegroup_(self.handle)
         if status == ERROR:
@@ -603 +604 @@
         if status == ERROR:
             raise ValueError, "Could not get group info: %s"%(self._loc())
-        #print "group info",nxclass.value,name.value,n.value
+        #print "getgroupinfo",self._loc(),nxclass.value,name.value,n.value
         name = path.value.split('/')[-1]  # Protect against HDF5 returning path
         return n.value,name,nxclass.value
@@ -655 +656 @@
         #if nxclass == 'SDS':
         #    dtype = _pytype_code(storage.value)
-        #print "group next",nxclass.value, name.value, storage.value
+        #print "nextentry",nxclass.value, name.value, storage.value
         return name.value,nxclass.value
 
@@ -728 +729 @@
 
     # ==== Data ====
-    nxlib.nxigetinfo_.restype = c_int
-    nxlib.nxigetinfo_.argtypes = [c_void_p, c_int_p, c_void_p, c_int_p]
-    def getinfo(self):
+    nxlib.nxigetrawinfo_.restype = c_int
+    nxlib.nxigetrawinfo_.argtypes = [c_void_p, c_int_p, c_void_p, c_int_p]
+    def getrawinfo(self):
         """
         Returns the tuple dimensions,type for the currently open dataset.
@@ -740 +741 @@
         complex values.
 
+        Unlike getinfo(), the size of the string storage area is
+        returned rather than the length of the stored string.
+
+        Raises NeXusError if this fails.
+
+        Corresponds to NXgetrawinfo(handle, &rank, dims, &storage),
+        but with storage converted from HDF values to numpy compatible
+        strings, and rank implicit in the length of the returned dimensions.
+        """
+        rank = c_int(0)
+        shape = numpy.zeros(MAXRANK, 'i')
+        storage = c_int(0)
+        status = nxlib.nxigetrawinfo_(self.handle, _ref(rank), shape.ctypes.data,
+                                     _ref(storage))
+        if status == ERROR:
+            raise NeXusError, "Could not get data info: %s"%(self._loc())
+        shape = shape[:rank.value]+0
+        dtype = _pytype_code[storage.value]
+        #print "getrawinfo",self._loc(),"->",shape,dtype
+        return shape,dtype
+
+    nxlib.nxigetinfo_.restype = c_int
+    nxlib.nxigetinfo_.argtypes = [c_void_p, c_int_p, c_void_p, c_int_p]
+    def getinfo(self):
+        """
+        Returns the tuple dimensions,type for the currently open dataset.
+        Dimensions is an integer array whose length corresponds to the rank
+        of the dataset and whose elements are the size of the individual
+        dimensions.  Storage type is returned as a string, with 'char' for
+        a stored string, '[u]int[8|16|32]' for various integer values or
+        'float[32|64]' for floating point values.  No support for
+        complex values.
+
+        Unlike getrawinfo(), the length of the stored string is
+        returned rather than the size of the string storage area.
+
         Raises NeXusError if this fails.
 
@@ -758 +795 @@
         shape = shape[:rank.value]+0
         dtype = _pytype_code[storage.value]
-        #print "data info",shape,dtype
+        #print "getinfo",self._loc(),"->",shape,dtype
         return shape,dtype
 
@@ -771 +808 @@
         Corresponds to NXopendata(handle, name)
         """
-        #print "opening data",name
+        #print "opendata",self._loc(),name
         status = nxlib.nxiopendata_(self.handle, name)
         if status == ERROR:
@@ -789 +826 @@
         Corresponds to NXclosedata(handle)
         """
-        #print "closing data"
+        #print "closedata"
         status = nxlib.nxiclosedata_(self.handle)
         if status == ERROR:
@@ -815 +852 @@
         # TODO: With keywords for value and attr, this can be used for
         # TODO: makedata, opendata, putdata, putattr, putattr, ..., closedata
-        #print "Data",name,dtype,shape
+        #print "makedata",self._loc(),name,shape,dtype
         storage = _nxtype_code[str(dtype)]
         shape = numpy.array(shape,'i')
@@ -865 +902 @@
         Return the data.  If data is a string (1-D char array), a python
         string is returned.  If data is a scalar (1-D numeric array of
-        length 1), a python numeric scalar is returned.
+        length 1), a python scalar is returned.  If data is a string 
+        array, a numpy array of type 'S#' where # is the maximum string
+        length is returned.  If data is a numeric array, a numpy array
+        is returned.
 
         Raises ValueError if this fails.
@@ -873 +913 @@
         # TODO: consider accepting preallocated data so we don't thrash memory
         shape,dtype = self.getinfo()
-        datafn,pdata,size = self._poutput(dtype,shape)
+        data,pdata,size,datafn = self._poutput(dtype,shape)
         status = nxlib.nxigetdata_(self.handle,pdata)
         if status == ERROR:
             raise ValueError, "Could not read data: %s"%(self._loc())
-        #print "data",ret()
+        #print "getdata",self._loc(),shape,dtype
         return datafn()
 
@@ -894 +934 @@
         """
         # TODO: consider accepting preallocated data so we don't thrash memory
-        shape,dtype = self.getinfo()
-        datafn,pdata,size = self._poutput(dtype,slab_shape)
+        shape,dtype = self.getrawinfo()
+        data,pdata,size,datafn = self._poutput(dtype,slab_shape)
         slab_offset = numpy.array(slab_offset,'i')
         slab_shape = numpy.array(slab_shape,'i')
@@ -916 +956 @@
         Corresponds to NXputdata(handle, data)
         """
-        shape,dtype = self.getinfo()
+        shape,dtype = self.getrawinfo()
+        #print "putdata",self._loc(),shape,dtype
         data,pdata = self._pinput(data,dtype,shape)
         status = nxlib.nxiputdata_(self.handle,pdata)
@@ -935 +976 @@
         Corresponds to NXputslab(handle,data,offset,shape)
         """
-        shape,dtype = self.getinfo()
+        shape,dtype = self.getrawinfo()
         data,pdata = self._pinput(data,dtype,slab_shape)
         slab_offset = numpy.array(slab_offset,'i')
@@ -1011 +1052 @@
             raise NeXusError, "Could not get next attr: %s"%(self._loc())
         dtype = _pytype_code[storage.value]
-        #print "next attr",name.value,length.value,dtype
+        #print "getnextattr",name.value,length.value,dtype
         return name.value, length.value, dtype
 
@@ -1027 +1068 @@
         """
         if dtype is 'char': length += 1  # HDF4 needs zero-terminator
-        datafn,pdata,size = self._poutput(str(dtype),[length])
+        data,pdata,size,datafn = self._poutput(str(dtype),[length])
         storage = c_int(_nxtype_code[str(dtype)])
-        #print "retrieving",name,length,dtype,size
+        #print "getattr",self._loc(),name,length,size,dtype
         size = c_int(size)
         status = nxlib.nxigetattr_(self.handle,name,pdata,_ref(size),_ref(storage))
         if status == ERROR:
             raise ValueError, "Could not read attr %s: %s" % (name,self._loc())
-        #print "attr",name,datafn(),size
+        #print "getattr",self._loc(),name,datafn()
         return datafn()
 
@@ -1304 +1345 @@
         """
         Build space to collect a nexus data element.
-        Returns datafn,data,size where
-        - datafn is a lamba expression to extract the value out of the element.
-        - pdata is the value to pass to C (effectively a void *)
+        Returns data,pdata,size,datafn where
+        - data is a python type to hold the returned data
+        - pdata is the pointer to the start of the data
         - size is the number of bytes in the data block
-        Note that ret can return a string, a scalar or an array depending
+        - datafn is a lamba expression to extract the return value from data
+        Note that datafn can return a string, a scalar or an array depending
         on the data type and shape of the data group.
         """
@@ -1314 +1356 @@
             # string - use ctypes allocator
             size = int(shape[0])
-            pdata = ctypes.create_string_buffer(size)
-            datafn = lambda: pdata.value
+            data = ctypes.create_string_buffer(size)
+            pdata = data
+            datafn = lambda: data.value
         else:
-            # numeric - use numpy array
-            if dtype=='char': dtype = 'uint8'
-            data = numpy.zeros(shape,dtype)
+            # scalar, array or string list - use numpy array
+            if dtype=='char': 
+                data = numpy.zeros(shape[:-1], dtype='S%i'%shape[-1])
+            else:
+                data = numpy.zeros(shape, dtype)
             if len(shape) == 1 and shape[0] == 1:
                 datafn = lambda: data[0]
@@ -1326 +1371 @@
             pdata = data.ctypes.data
             size = data.nbytes
-        return datafn,pdata,size
+        return data,pdata,size,datafn
 
     def _pinput(self, data, dtype, shape):
         """
-        Convert an input array to a C pointer to a dense array.  This may
-        require conversion of the array, so the new array is returned along
-        with its pointer.
+        Convert an input array to a C pointer to a dense array.
+
+        Returns data, pdata where 
+        - data is a possibly new copy of the array
+        - pdata is a pointer to the beginning of the array.  
+        Note that you must hold a reference to data for as long 
+        as you need pdata to keep the memory from being released to the heap.
         """
         if dtype == "char":
-            # Character data - pad with zeros to the right length
-            if not _is_string_like(data):
-                raise ValueError,"Expected character data: %s"%(self._loc())
-            if len(data) < shape[0]:
-                data += '\000'*(shape[0]-len(data))
+            data = numpy.asarray(data, dtype='S%d'%(shape[-1]))
         else:
             # Convert scalars to vectors of length one
             if numpy.prod(shape) == 1 and not hasattr(data,'shape'):
-                data = numpy.array([data],dtype=dtype)
+                data = numpy.array([data], dtype=dtype)
             # Check that dimensions match
             # Ick! need to exclude dimensions of length 1 in order to catch
@@ -1349 +1394 @@
             input_shape = numpy.array([i for i in data.shape if i != 1])
             target_shape = numpy.array([i for i in shape if i != 1])
-            if len(input_shape) != len(target_shape) or (input_shape != target_shape).any():
+            if len(input_shape) != len(target_shape) \
+                    or (input_shape != target_shape).any():
                 raise ValueError,\
-                    "Shape mismatch %s!=%s: %s"%(data.shape,shape,self.filename)
+                    "Shape mismatch %s!=%s: %s"%(data_shape,shape,self._loc())
+            # Check data type
             if str(data.dtype) != dtype:
                 raise ValueError,\
                     "Type mismatch %s!=%s: %s"%(dtype,data.dtype,self._loc())
 
-        if dtype == 'char':
-            # String: hand it over as usual for strings.  Assumes the string
-            # is the correct length for the storage area.
-            pdata = data
-        else:
-            # Vector: assume it is of the correct storage class and size
-            data = numpy.ascontiguousarray(data)
-            pdata = data.ctypes.data
-
+        data = numpy.ascontiguousarray(data)
+        pdata = data.ctypes.data
+            
         return data,pdata