Changeset 1171

Timestamp:

16/01/09 23:26:16 (3 years ago)

Author:

Paul Kienzle

Message:

xml getattrinfo now returns correct number of attrs for root; nxstest now skips bogus CDF0.0 entry in HDF4 root; nxs/napi.py now reimplements openpath so that nexus file knows its current path. Refs #149.

Location:

trunk

Files:

• bindings/python/nxs/napi.py (modified) (18 diffs)
• bindings/python/nxstest.py (modified) (3 diffs)
• src/nxxml.c (modified) (2 diffs)

trunk/bindings/python/nxs/napi.py

@@ -301 +301 @@
         self.filename, self.mode = filename, mode
         self.handle = c_void_p(None)
-        self.path = []
+        self._path = []
+        self._indata = False
         status = nxlib.nxiopen_(filename,mode,_ref(self.handle))
         if status == ERROR:
@@ -311 +312 @@
         self.isopen = True
 
+    def _getpath(self): 
+        return '/'+'/'.join(self._path)
+    path = property(_getpath,doc="Unix-style path to node")
+
     def __del__(self):
         """
@@ -341 +346 @@
         if status == ERROR:
             raise NeXusError, "Could not open %s"%(self.filename)
-        self.path = []
+        self._path = []
+        self._indata = False
 
     nxlib.nxiclose_.restype = c_int
@@ -358 +364 @@
             if status == ERROR:
                 raise NeXusError, "Could not close NeXus file %s"%(self.filename)
-        self.path = []
+        self._path = []
+        self._indata = False
 
     nxlib.nxiflush_.restype = c_int
@@ -412 +419 @@
         """
         Open a particular group '/path/to/group'.  Paths can
-        be relative to the currently open group.
+        be absolute or relative to the currently open group.
+        If openpath fails, then currently open path may not
+        be different from the starting path.
 
         Raises ValueError.
@@ -418 +427 @@
         Corresponds to NXopenpath(handle, path)
         """
-        status = nxlib.nxiopenpath_(self.handle, path)
-        if status == ERROR:
-            raise ValueError, "Could not open %s in %s"%(path,self._loc())
-        n,path,nxclass = self.getgroupinfo()
-        if path != 'root':
-            self.path = path.split('/')
+        self._openpath(path, opendata=True)
+
+    def _openpath(self, path, opendata=True):
+        """helper function: open relative path and maybe data"""
+        # Determine target node as sequence of group names
+        if path == '/':
+            target = []
+        elif path.startswith('/'):
+            target = path[1:].split('/')
         else:
-            self.path = []
-
+            target = self._path + path.split('/')
+
+        # Remove relative path indicators from target
+        L = []
+        for t in target:
+            if t == '.': 
+                # Skip current node
+                pass
+            elif t == '..':
+                if L == []:
+                    raise ValueError("too many '..' in path")
+                L.pop()
+            else:
+                L.append(t)
+        target = L
+        #print "current path",self._path
+        #print "%s"%path,target
+
+        # Find which groups need to be closed and opened
+        up = []
+        down = []
+        for i,name in enumerate(target):
+            if i == len(self._path):
+                #print "target longer than current"
+                up = []
+                down = target[i:]
+                break
+            elif self._path[i] != name:
+                #print "target and current differ at",name
+                up = self._path[i:]
+                down = target[i:]
+                break
+        else:
+            #print "target shorter than current"
+            up = self._path[len(target):]
+            down = []
+        up.reverse()
+        #print "close,open",up,down
+
+        # Close groups on the way up
+        if self._indata and up != []:
+            self.closedata()
+            up.pop()
+        for target in up:
+            self.closegroup()
+        
+        # Open groups on the way down
+        for target in down:
+            # Find target name in current group.  We need to do this because
+            # we can't open the group without knowing the class.  We also
+            # need the class so that we can handle SDS specially.
+            n,_,_ = self.getgroupinfo()
+            self.initgroupdir()
+            for i in range(n):
+                name,nxclass = self.getnextentry()
+                if name != target: continue
+                if nxclass != 'SDS':
+                    self.opengroup(name,nxclass)
+                elif opendata: 
+                    self.opendata(name)
+                break
+            else:
+                raise ValueError("node %s not in %s"%(name,self.path))
 
     nxlib.nxiopengrouppath_.restype = c_int
@@ -440 +513 @@
         Corresponds to NXopengrouppath(handle, path)
         """
-        status = nxlib.nxiopengrouppath_(self.handle, path)
-        if status == ERROR:
-            raise ValueError, "Could not open %s in %s"%(path,self.filename)
-        n,path,nxclass = self.getgroupinfo()
-        if path != 'root':
-            self.path = path.split('/')
-        else:
-            self.path = []
-
+        self._openpath(path,opendata=False)
 
     nxlib.nxiopengroup_.restype = c_int
@@ -465 +530 @@
             raise ValueError,\
                 "Could not open %s:%s in %s"%(nxclass,name,self._loc())
-        self.path.append(name)
+        self._path.append(name)
 
     nxlib.nxiclosegroup_.restype = c_int
@@ -479 +544 @@
         #print "close group"
         status = nxlib.nxiclosegroup_(self.handle)
-        group = self.path.pop()
-        if status == ERROR:
-            raise NeXusError, "Could not close %s:"%(group,self._loc())
-
-    nxlib.nxigetinfo_.restype = c_int
-    nxlib.nxigetinfo_.argtypes = [c_void_p, c_int_p, c_char_p, c_char_p]
+        if status == ERROR:
+            raise NeXusError, "Could not close group at %s"%(name,self._loc())
+        self._path.pop()
+
+    nxlib.nxigetgroupinfo_.restype = c_int
+    nxlib.nxigetgroupinfo_.argtypes = [c_void_p, c_int_p, c_char_p, c_char_p]
     def getgroupinfo(self):
         """
         Query the currently open group returning the tuple
-        numentries, path, nxclass.  The path consists of names
-        of subgroups starting at the root separated by "/".
+        numentries, name, nxclass.
 
         Raises ValueError if the group could not be opened.
 
         Corresponds to NXgetgroupinfo(handle)
+
+        Note: corrects error in HDF5 where getgroupinfo returns the entire
+        path rather than the group name.  Use the path attribute to get
+        a sensible value of path.
         """
         # Space for the returned strings
@@ -503 +571 @@
             raise ValueError, "Could not get group info: %s"%(self._loc())
         #print "group info",nxclass.value,name.value,n.value
-        return n.value,path.value,nxclass.value
+        name = path.value.split('/')[-1]  # Protect against HDF5 returning path
+        return n.value,name,nxclass.value
 
     nxlib.nxiinitgroupdir_.restype = c_int
@@ -566 +635 @@
         # first, then process the entries one by one.  Keep track
         # of the path so we can restore it between entries.
-        n,path,_ = self.getgroupinfo()
-        #print "path",path
-        if not path == "root":
-            path = "/"+path
-        else:
-            path = "/"
+        path = self.path
 
         # Read list of entries
         self.initgroupdir()
+        n,_,_ = self.getgroupinfo()
         L = []
         for i in range(n):
@@ -634 +699 @@
         if status == ERROR:
             raise ValueError, "Could not open data %s: %s"%(name, self._loc())
-        self.path.append(name)
+        self._path.append(name)
+        self._indata = True
 
     nxlib.nxiclosedata_.restype = c_int
@@ -649 +715 @@
         #print "closing data"
         status = nxlib.nxiclosedata_(self.handle)
-        name = self.path.pop()
         if status == ERROR:
             raise NeXusError,\
-                "Could not close data %s: %s"%(name,self._loc())
+                "Could not close data at %s"%(name,self._loc())
+        self._path.pop()
+        self._indata = False
 
     nxlib.nximakedata_.restype = c_int
@@ -881 +948 @@
         Corresponds to NXgetattr(handle,name,data,&length,&storage)
         """
+        if dtype is 'char': length += 1  # HDF4 needs zero-terminator
         datafn,pdata,size = self._poutput(str(dtype),[length])
         storage = c_int(_nxtype_code[str(dtype)])
@@ -1065 +1133 @@
         combines the work of attrinfo/initattrdir/getnextattr/getattr.
         """
-        # To preserve the semantics we must read in the whole list
-        # first, then process the entries one by one.
-        pathstr = "/"+"/".join(self.path)
-        #print "checking for links from",pathstr
         n = self.getattrinfo()
         self.initattrdir()
@@ -1075 +1139 @@
             if name == "target":
                 target = self.getattr(name,length,dtype)
-                #print "target %s, path %s"%(target,pathstr)
-                if target != pathstr:
+                #print "target %s, path %s"%(target,self.path)
+                if target != self.path:
                     return target
                 else:
@@ -1142 +1206 @@
     def _loc(self):
         """
-        Return file location as string filename:path
+        Return file location as string filename(path)
 
         This is an extension to the NeXus API.
         """
-        if not self.path == []:
-            pathstr = "/".join(self.path)
-        else:
-            pathstr = "root"
-        return "%s(%s)"%(self.filename,pathstr)
+        return "%s(%s)"%(self.filename,self.path)
 
     def _poutput(self, dtype, shape):
@@ -1224 +1284 @@
         TODO: Break this into a tree walker and a visitor.
         """
-        oldpath = "/"+"/".join(self.path)
-        if not path: path = oldpath
+        oldpath = self.path
         self.openpath(path)
 

trunk/bindings/python/nxstest.py

@@ -45 +45 @@
         print "%(prefix)s@%(attr)s: %(value)s" % locals()
     for name,nxclass in file.entries():
+        if nxclass.startswith("CDF"): continue # Root has an extra CDF class
         if nxclass == "SDS":
             shape,dtype = file.getinfo()
@@ -189 +190 @@
     file = nxs.open(filename,'rw')
     if filename != file.inquirefile(): fail("Files don't match")
-    attrs = file.getattrinfo()
-    if attrs != 4: fail("Expected 4 root attributes but got %d", attrs)
-    for i in range(attrs):
+
+    # check headers
+    num_attrs = file.getattrinfo()
+    wxattrs = ['xmlns','xmlns:xsi','xsi:schemaLocation', 'XML_version']
+    w4attrs = ['HDF_version']
+    w5attrs = ['HDF5_Version']
+    extras = dict(wx=wxattrs,w4=w4attrs,w5=w5attrs)
+    expected_attrs = ['NeXus_version','file_name','file_time']+extras[mode]
+    for i in range(num_attrs):
         name,dims,type = file.getnextattr()
-        if name not in ['file_time','HDF_version','HDF5_Version','XML_version',
-                        'NeXus_version','file_name']:
+        if name not in expected_attrs:
             fail("attribute %s unexpected"%(name))
+    if num_attrs != len(expected_attrs): 
+        fail("Expected %d root attributes but got %d"
+             % (len(expected_attrs),num_attrs))
     
     file.opengroup('entry','NXentry')
@@ -230 +239 @@
     if not get == numpy.int32(42): fail("i4_attribute retrieved %s"%(get))
     get = file.getattr("r4_attribute",1,'float32')
-    if not get == numpy.float32(3.14159265): fail("r4_attribute retrieved %s"%(get))
+    if ((mode=='wx' and not abs(get-3.14159265) < 1e-6) or
+        (mode!='wx' and not get == numpy.float32(3.14159265))):
+        fail("r4_attribute retrieved %s"%(get))
     ## Oops... NAPI doesn't support array attributes
     #expect = numpy.array([3,2],dtype='int32')

trunk/src/nxxml.c

@@ -1666 +1666 @@
   pXMLNexus xmlHandle = NULL;
   mxml_node_t *current = NULL;
-  int stackPtr, currentAtt;
+  int stackPtr, currentAtt, skip;
 
   xmlHandle = (pXMLNexus)fid;
@@ -1678 +1678 @@
     hide type and group name attributes
   */
-  if(!isDataNode(current)) {
-    *iN = current->value.element.num_attrs -1;
-    return NX_OK;
-  }
-  if(mxmlElementGetAttr(current,TYPENAME) != NULL){
-    *iN = current->value.element.num_attrs -1;
+  skip=0;
+  if(isDataNode(current)) {
+    /* data nodes may have type */
+    if(mxmlElementGetAttr(current,TYPENAME) != NULL) skip=1;
   } else {
-    *iN = current->value.element.num_attrs;
-  }
+    /* group nodes (except root) have name */
+    if(mxmlElementGetAttr(current,"name") != NULL) skip=1;
+  }
+  *iN = current->value.element.num_attrs - skip;
   return NX_OK;
 }