[h5py] 05/26: Fix line ending weirdness in h5t.pyx

Ghislain Vaillant ghisvail-guest at moszumanska.debian.org
Thu Jul 2 18:20:16 UTC 2015


This is an automated email from the git hooks/post-receive script.

ghisvail-guest pushed a commit to annotated tag 1.3.1
in repository h5py.

commit 849e0ce7d904247d4c36a0be0a9da18d75e3f81e
Author: andrewcollette <andrew.collette at gmail.com>
Date:   Tue Jun 22 17:08:06 2010 +0000

    Fix line ending weirdness in h5t.pyx
---
 h5py/h5t.pyx | 2838 +++++++++++++++++++++++++++++-----------------------------
 1 file changed, 1419 insertions(+), 1419 deletions(-)

diff --git a/h5py/h5t.pyx b/h5py/h5t.pyx
index e9f437e..15d927e 100644
--- a/h5py/h5t.pyx
+++ b/h5py/h5t.pyx
@@ -1,1246 +1,1246 @@
-#+
-# 
-# This file is part of h5py, a low-level Python interface to the HDF5 library.
-# 
-# Copyright (C) 2008 Andrew Collette
-# http://h5py.alfven.org
-# License: BSD  (See LICENSE.txt for full license)
-# 
-# $Date$
-# 
-#-
-
-"""
-    HDF5 "H5T" data-type API
-
-    This module contains the datatype identifier class TypeID, and its
-    subclasses which represent things like integer/float/compound identifiers.
-    The majority of the H5T API is presented as methods on these identifiers.
-"""
-
-include "config.pxi"
-
-# Pyrex compile-time imports
-from h5 cimport init_hdf5, H5PYConfig, get_config
-from h5p cimport PropID, pdefault
-from numpy cimport dtype, ndarray
-from python_string cimport PyString_FromStringAndSize
+#+
+# 
+# This file is part of h5py, a low-level Python interface to the HDF5 library.
+# 
+# Copyright (C) 2008 Andrew Collette
+# http://h5py.alfven.org
+# License: BSD  (See LICENSE.txt for full license)
+# 
+# $Date$
+# 
+#-
+
+"""
+    HDF5 "H5T" data-type API
+
+    This module contains the datatype identifier class TypeID, and its
+    subclasses which represent things like integer/float/compound identifiers.
+    The majority of the H5T API is presented as methods on these identifiers.
+"""
+
+include "config.pxi"
+
+# Pyrex compile-time imports
+from h5 cimport init_hdf5, H5PYConfig, get_config
+from h5p cimport PropID, pdefault
+from numpy cimport dtype, ndarray
+from python_string cimport PyString_FromStringAndSize
 from h5r cimport Reference, RegionReference
-
-from utils cimport  emalloc, efree, \
-                    require_tuple, convert_dims, convert_tuple
+
+from utils cimport  emalloc, efree, \
+                    require_tuple, convert_dims, convert_tuple
 import _conv
-
-# Initialization
-init_hdf5()
-
-# Runtime imports
-import sys
-import h5
+
+# Initialization
+init_hdf5()
+
+# Runtime imports
+import sys
+import h5
 
 cdef H5PYConfig cfg = get_config()
-
-# === Custom C API ============================================================
-
-cdef TypeID typewrap(hid_t id_):
-
-    cdef H5T_class_t cls
-    cls = H5Tget_class(id_)
-
-    if cls == H5T_INTEGER:
-        pcls = TypeIntegerID
-    elif cls == H5T_FLOAT:
-        pcls = TypeFloatID
-    elif cls == H5T_TIME:
-        pcls = TypeTimeID
-    elif cls == H5T_STRING:
-        pcls = TypeStringID
-    elif cls == H5T_BITFIELD:
-        pcls = TypeBitfieldID
-    elif cls == H5T_OPAQUE:
-        pcls = TypeOpaqueID
-    elif cls == H5T_COMPOUND:
-        pcls = TypeCompoundID
-    elif cls == H5T_REFERENCE:
-        pcls = TypeReferenceID
-    elif cls == H5T_ENUM:
-        pcls = TypeEnumID
-    elif cls == H5T_VLEN:
-        pcls = TypeVlenID
-    elif cls == H5T_ARRAY:
-        pcls = TypeArrayID
-    else:
-        pcls = TypeID
-
-    return pcls(id_)
-
-cdef object lockid(hid_t id_in):
-    cdef TypeID tid
-    tid = typewrap(id_in)
-    tid._locked = 1
-    return tid
-
-# === Public constants and data structures ====================================
-
-
-# Enumeration H5T_class_t
-NO_CLASS  = H5T_NO_CLASS
-INTEGER   = H5T_INTEGER
-FLOAT     = H5T_FLOAT
-TIME      = H5T_TIME
-STRING    = H5T_STRING
-BITFIELD  = H5T_BITFIELD
-OPAQUE    = H5T_OPAQUE
-COMPOUND  = H5T_COMPOUND
-REFERENCE = H5T_REFERENCE
-ENUM      = H5T_ENUM
-VLEN      = H5T_VLEN
-ARRAY     = H5T_ARRAY
-
-# Enumeration H5T_sign_t
-SGN_NONE   = H5T_SGN_NONE
-SGN_2      = H5T_SGN_2
-
-# Enumeration H5T_order_t
-ORDER_LE    = H5T_ORDER_LE
-ORDER_BE    = H5T_ORDER_BE
-ORDER_VAX   = H5T_ORDER_VAX
-ORDER_NONE  = H5T_ORDER_NONE
-
-DIR_DEFAULT = H5T_DIR_DEFAULT
-DIR_ASCEND  = H5T_DIR_ASCEND
-DIR_DESCEND = H5T_DIR_DESCEND
-
-# Enumeration H5T_str_t
-STR_NULLTERM = H5T_STR_NULLTERM
-STR_NULLPAD  = H5T_STR_NULLPAD
-STR_SPACEPAD = H5T_STR_SPACEPAD
-
-# Enumeration H5T_norm_t
-NORM_IMPLIED = H5T_NORM_IMPLIED
-NORM_MSBSET = H5T_NORM_MSBSET
-NORM_NONE = H5T_NORM_NONE
-
-# Enumeration H5T_cset_t:
-CSET_ASCII = H5T_CSET_ASCII
-
-# Enumeration H5T_pad_t:
-PAD_ZERO = H5T_PAD_ZERO
-PAD_ONE = H5T_PAD_ONE
-PAD_BACKGROUND = H5T_PAD_BACKGROUND
-
-if sys.byteorder == "little":    # Custom python addition
-    ORDER_NATIVE = H5T_ORDER_LE
-else:
-    ORDER_NATIVE = H5T_ORDER_BE
+
+# === Custom C API ============================================================
+
+cdef TypeID typewrap(hid_t id_):
+
+    cdef H5T_class_t cls
+    cls = H5Tget_class(id_)
+
+    if cls == H5T_INTEGER:
+        pcls = TypeIntegerID
+    elif cls == H5T_FLOAT:
+        pcls = TypeFloatID
+    elif cls == H5T_TIME:
+        pcls = TypeTimeID
+    elif cls == H5T_STRING:
+        pcls = TypeStringID
+    elif cls == H5T_BITFIELD:
+        pcls = TypeBitfieldID
+    elif cls == H5T_OPAQUE:
+        pcls = TypeOpaqueID
+    elif cls == H5T_COMPOUND:
+        pcls = TypeCompoundID
+    elif cls == H5T_REFERENCE:
+        pcls = TypeReferenceID
+    elif cls == H5T_ENUM:
+        pcls = TypeEnumID
+    elif cls == H5T_VLEN:
+        pcls = TypeVlenID
+    elif cls == H5T_ARRAY:
+        pcls = TypeArrayID
+    else:
+        pcls = TypeID
+
+    return pcls(id_)
+
+cdef object lockid(hid_t id_in):
+    cdef TypeID tid
+    tid = typewrap(id_in)
+    tid._locked = 1
+    return tid
+
+# === Public constants and data structures ====================================
+
+
+# Enumeration H5T_class_t
+NO_CLASS  = H5T_NO_CLASS
+INTEGER   = H5T_INTEGER
+FLOAT     = H5T_FLOAT
+TIME      = H5T_TIME
+STRING    = H5T_STRING
+BITFIELD  = H5T_BITFIELD
+OPAQUE    = H5T_OPAQUE
+COMPOUND  = H5T_COMPOUND
+REFERENCE = H5T_REFERENCE
+ENUM      = H5T_ENUM
+VLEN      = H5T_VLEN
+ARRAY     = H5T_ARRAY
+
+# Enumeration H5T_sign_t
+SGN_NONE   = H5T_SGN_NONE
+SGN_2      = H5T_SGN_2
+
+# Enumeration H5T_order_t
+ORDER_LE    = H5T_ORDER_LE
+ORDER_BE    = H5T_ORDER_BE
+ORDER_VAX   = H5T_ORDER_VAX
+ORDER_NONE  = H5T_ORDER_NONE
+
+DIR_DEFAULT = H5T_DIR_DEFAULT
+DIR_ASCEND  = H5T_DIR_ASCEND
+DIR_DESCEND = H5T_DIR_DESCEND
+
+# Enumeration H5T_str_t
+STR_NULLTERM = H5T_STR_NULLTERM
+STR_NULLPAD  = H5T_STR_NULLPAD
+STR_SPACEPAD = H5T_STR_SPACEPAD
+
+# Enumeration H5T_norm_t
+NORM_IMPLIED = H5T_NORM_IMPLIED
+NORM_MSBSET = H5T_NORM_MSBSET
+NORM_NONE = H5T_NORM_NONE
+
+# Enumeration H5T_cset_t:
+CSET_ASCII = H5T_CSET_ASCII
+
+# Enumeration H5T_pad_t:
+PAD_ZERO = H5T_PAD_ZERO
+PAD_ONE = H5T_PAD_ONE
+PAD_BACKGROUND = H5T_PAD_BACKGROUND
+
+if sys.byteorder == "little":    # Custom python addition
+    ORDER_NATIVE = H5T_ORDER_LE
+else:
+    ORDER_NATIVE = H5T_ORDER_BE
 
 # For conversion
 BKG_NO = H5T_BKG_NO
 BKG_TEMP = H5T_BKG_TEMP
 BKG_YES = H5T_BKG_YES
-
-# --- Built-in HDF5 datatypes -------------------------------------------------
-
-# IEEE floating-point
-IEEE_F32LE = lockid(H5T_IEEE_F32LE)
-IEEE_F32BE = lockid(H5T_IEEE_F32BE)
-IEEE_F64LE = lockid(H5T_IEEE_F64LE)
-IEEE_F64BE = lockid(H5T_IEEE_F64BE)
-
-# Signed 2's complement integer types
-STD_I8LE  = lockid(H5T_STD_I8LE)
-STD_I16LE = lockid(H5T_STD_I16LE)
-STD_I32LE = lockid(H5T_STD_I32LE)
-STD_I64LE = lockid(H5T_STD_I64LE)
-
-STD_I8BE  = lockid(H5T_STD_I8BE)
-STD_I16BE = lockid(H5T_STD_I16BE)
-STD_I32BE = lockid(H5T_STD_I32BE)
-STD_I64BE = lockid(H5T_STD_I64BE)
-
-# Unsigned integers
-STD_U8LE  = lockid(H5T_STD_U8LE)
-STD_U16LE = lockid(H5T_STD_U16LE)
-STD_U32LE = lockid(H5T_STD_U32LE)
-STD_U64LE = lockid(H5T_STD_U64LE)
-
-STD_U8BE  = lockid(H5T_STD_U8BE)
-STD_U16BE = lockid(H5T_STD_U16BE)
-STD_U32BE = lockid(H5T_STD_U32BE)
-STD_U64BE = lockid(H5T_STD_U64BE)
-
-# Native types by bytesize
-NATIVE_INT8 = lockid(H5T_NATIVE_INT8)
-NATIVE_UINT8 = lockid(H5T_NATIVE_UINT8)
-NATIVE_INT16 = lockid(H5T_NATIVE_INT16)
-NATIVE_UINT16 = lockid(H5T_NATIVE_UINT16)
-NATIVE_INT32 = lockid(H5T_NATIVE_INT32)
-NATIVE_UINT32 = lockid(H5T_NATIVE_UINT32)
-NATIVE_INT64 = lockid(H5T_NATIVE_INT64)
-NATIVE_UINT64 = lockid(H5T_NATIVE_UINT64)
-NATIVE_FLOAT = lockid(H5T_NATIVE_FLOAT)
-NATIVE_DOUBLE = lockid(H5T_NATIVE_DOUBLE)
-
-# Unix time types
-UNIX_D32LE = lockid(H5T_UNIX_D32LE)
-UNIX_D64LE = lockid(H5T_UNIX_D64LE)
-UNIX_D32BE = lockid(H5T_UNIX_D32BE)
-UNIX_D64BE = lockid(H5T_UNIX_D64BE)
-
-# Reference types
-STD_REF_OBJ = lockid(H5T_STD_REF_OBJ)
-STD_REF_DSETREG = lockid(H5T_STD_REF_DSETREG)
-
-# Null terminated (C) and Fortran string types
-C_S1 = lockid(H5T_C_S1)
-FORTRAN_S1 = lockid(H5T_FORTRAN_S1)
-VARIABLE = H5T_VARIABLE
-
+
+# --- Built-in HDF5 datatypes -------------------------------------------------
+
+# IEEE floating-point
+IEEE_F32LE = lockid(H5T_IEEE_F32LE)
+IEEE_F32BE = lockid(H5T_IEEE_F32BE)
+IEEE_F64LE = lockid(H5T_IEEE_F64LE)
+IEEE_F64BE = lockid(H5T_IEEE_F64BE)
+
+# Signed 2's complement integer types
+STD_I8LE  = lockid(H5T_STD_I8LE)
+STD_I16LE = lockid(H5T_STD_I16LE)
+STD_I32LE = lockid(H5T_STD_I32LE)
+STD_I64LE = lockid(H5T_STD_I64LE)
+
+STD_I8BE  = lockid(H5T_STD_I8BE)
+STD_I16BE = lockid(H5T_STD_I16BE)
+STD_I32BE = lockid(H5T_STD_I32BE)
+STD_I64BE = lockid(H5T_STD_I64BE)
+
+# Unsigned integers
+STD_U8LE  = lockid(H5T_STD_U8LE)
+STD_U16LE = lockid(H5T_STD_U16LE)
+STD_U32LE = lockid(H5T_STD_U32LE)
+STD_U64LE = lockid(H5T_STD_U64LE)
+
+STD_U8BE  = lockid(H5T_STD_U8BE)
+STD_U16BE = lockid(H5T_STD_U16BE)
+STD_U32BE = lockid(H5T_STD_U32BE)
+STD_U64BE = lockid(H5T_STD_U64BE)
+
+# Native types by bytesize
+NATIVE_INT8 = lockid(H5T_NATIVE_INT8)
+NATIVE_UINT8 = lockid(H5T_NATIVE_UINT8)
+NATIVE_INT16 = lockid(H5T_NATIVE_INT16)
+NATIVE_UINT16 = lockid(H5T_NATIVE_UINT16)
+NATIVE_INT32 = lockid(H5T_NATIVE_INT32)
+NATIVE_UINT32 = lockid(H5T_NATIVE_UINT32)
+NATIVE_INT64 = lockid(H5T_NATIVE_INT64)
+NATIVE_UINT64 = lockid(H5T_NATIVE_UINT64)
+NATIVE_FLOAT = lockid(H5T_NATIVE_FLOAT)
+NATIVE_DOUBLE = lockid(H5T_NATIVE_DOUBLE)
+
+# Unix time types
+UNIX_D32LE = lockid(H5T_UNIX_D32LE)
+UNIX_D64LE = lockid(H5T_UNIX_D64LE)
+UNIX_D32BE = lockid(H5T_UNIX_D32BE)
+UNIX_D64BE = lockid(H5T_UNIX_D64BE)
+
+# Reference types
+STD_REF_OBJ = lockid(H5T_STD_REF_OBJ)
+STD_REF_DSETREG = lockid(H5T_STD_REF_DSETREG)
+
+# Null terminated (C) and Fortran string types
+C_S1 = lockid(H5T_C_S1)
+FORTRAN_S1 = lockid(H5T_FORTRAN_S1)
+VARIABLE = H5T_VARIABLE
+
 # Custom Python object pointer type
 PYTHON_OBJECT = lockid(_conv.get_python_obj())
-
-#PYTHON_OBJECT = lockid(get_object_type())
-
-# Translation tables for HDF5 -> NumPy dtype conversion
-cdef dict _order_map = { H5T_ORDER_NONE: '|', H5T_ORDER_LE: '<', H5T_ORDER_BE: '>'}
-cdef dict _sign_map  = { H5T_SGN_NONE: 'u', H5T_SGN_2: 'i' }
-
-
-# === General datatype operations =============================================
-
-
-def create(int classtype, size_t size):
-    """(INT classtype, UINT size) => TypeID
-        
-    Create a new HDF5 type object.  Legal class values are 
-    COMPOUND and OPAQUE.  Use enum_create for enums.
-    """
-
-    # HDF5 versions 1.6.X segfault with anything else
-    if classtype != H5T_COMPOUND and classtype != H5T_OPAQUE:
-        raise ValueError("Class must be COMPOUND or OPAQUE.")
-
-    return typewrap(H5Tcreate(<H5T_class_t>classtype, size))
-
-
-def open(ObjectID group not None, char* name):
-    """(ObjectID group, STRING name) => TypeID
-
-    Open a named datatype from a file.
-    """
-    return typewrap(H5Topen(group.id, name))
-
-
-def array_create(TypeID base not None, object dims_tpl):
-    """(TypeID base, TUPLE dimensions) => TypeArrayID
-
-    Create a new array datatype, using and HDF5 parent type and
-    dimensions given via a tuple of positive integers.  "Unlimited" 
-    dimensions are not allowed.
-    """
-    cdef hsize_t rank
-    cdef hsize_t *dims = NULL
-
-    require_tuple(dims_tpl, 0, -1, "dims_tpl")
-    rank = len(dims_tpl)
-    dims = <hsize_t*>emalloc(sizeof(hsize_t)*rank)
-
-    try:
-        convert_tuple(dims_tpl, dims, rank)
-        return TypeArrayID(H5Tarray_create(base.id, rank, dims, NULL))
-    finally:
-        efree(dims)
-
-
-def enum_create(TypeID base not None):
-    """(TypeID base) => TypeID
-
-    Create a new enumerated type based on an (integer) parent type.
-    """
-    return typewrap(H5Tenum_create(base.id))
-
-
-def vlen_create(TypeID base not None):
-    """(TypeID base) => TypeID
-
-    Create a new variable-length datatype, using any HDF5 type as a base.
-
-    Although the Python interface can manipulate these types, there is no
-    provision for reading/writing vlen data.
-    """
-    return typewrap(H5Tvlen_create(base.id))
-
-IF H5PY_18API:
-    
-    def decode(char* buf):
-        """(STRING buf) => TypeID
-
-        Unserialize an HDF5 type.  You can also do this with the native
-        Python pickling machinery.
-        """
-        return typewrap(H5Tdecode(<unsigned char*>buf))
-
-# === Base type class =========================================================
-
-cdef class TypeID(ObjectID):
-
-    """
-        Base class for type identifiers (implements common operations)
-
-        * Hashable: If committed; in HDF5 1.8.X, also if locked
-        * Equality: Logical H5T comparison
-    """
-
-    def __hash__(self):
-        if self._hash is None:
-            try:
-                # Try to use object header first
-                return ObjectID.__hash__(self)
-            except TypeError:
-                # It's a transient type object
-                IF H5PY_18API:
-                    if self._locked:
-                        self._hash = hash(self.encode())
-                    else:
-                        raise TypeError("Only locked or committed types can be hashed")
-                ELSE:
-                    raise TypeError("Only committed types can be hashed")
-
-        return self._hash
-
-    def __richcmp__(self, object other, int how):
-        cdef bint truthval = 0
-        if how != 2 and how != 3:
-            return NotImplemented
-        if isinstance(other, TypeID):
-            truthval = self.equal(other)
-        
-        if how == 2:
-            return truthval
-        return not truthval
-
-    def __copy__(self):
-        cdef TypeID cpy
-        cpy = ObjectID.__copy__(self)
-        return cpy
-
-    property dtype:
-        """ A Numpy-style dtype object representing this object.
-        """
-        def __get__(self):
-            return self.py_dtype()
-
-    cdef object py_dtype(self):
-        raise TypeError("No NumPy equivalent for %s exists" % self.__class__.__name__)
-
-    IF H5PY_18API:
-        
-        def commit(self, ObjectID group not None, char* name, PropID lcpl=None):
-            """(ObjectID group, STRING name, PropID lcpl=None)
-
-            Commit this (transient) datatype to a named datatype in a file.
-            If present, lcpl may be a link creation property list.
-            """
-            H5Tcommit2(group.id, name, self.id, pdefault(lcpl),
-                H5P_DEFAULT, H5P_DEFAULT)
-    ELSE:
-        
-        def commit(self, ObjectID group not None, char* name):
-            """(ObjectID group, STRING name)
-
-            Commit this (transient) datatype to a named datatype in a file.
-            """
-            H5Tcommit(group.id, name, self.id)
-
-    
-    def committed(self):
-        """() => BOOL is_comitted
-
-        Determine if a given type object is named (T) or transient (F).
-        """
-        return <bint>(H5Tcommitted(self.id))
-
-    
-    def copy(self):
-        """() => TypeID
-
-        Create a copy of this type object.
-        """
-        return typewrap(H5Tcopy(self.id))
-
-    
-    def equal(self, TypeID typeid):
-        """(TypeID typeid) => BOOL
-
-        Logical comparison between datatypes.  Also called by
-        Python's "==" operator.
-        """
-        return <bint>(H5Tequal(self.id, typeid.id))
-
-    
-    def lock(self):
-        """()
-
-        Lock this datatype, which makes it immutable and indestructible.
-        Once locked, it can't be unlocked.
-        """
-        H5Tlock(self.id)
-        self._locked = 1
-
-    
-    def get_class(self):
-        """() => INT classcode
-
-        Determine the datatype's class code.
-        """
-        return <int>H5Tget_class(self.id)
-
-    
-    def set_size(self, size_t size):
-        """(UINT size)
-
-        Set the total size of the datatype, in bytes.
-        """
-        H5Tset_size(self.id, size)
-
-    
-    def get_size(self):
-        """ () => INT size
-
-            Determine the total size of a datatype, in bytes.
-        """
-        return H5Tget_size(self.id)
-
-    
-    def get_super(self):
-        """() => TypeID
-
-        Determine the parent type of an array, enumeration or vlen datatype.
-        """
-        return typewrap(H5Tget_super(self.id))
-
-    
-    def detect_class(self, int classtype):
-        """(INT classtype) => BOOL class_is_present
-
-        Determine if a member of the given class exists in a compound
-        datatype.  The search is recursive.
-        """
-        return <bint>(H5Tdetect_class(self.id, <H5T_class_t>classtype))
-
-    
-    def _close(self):
-        """()
-
-        Close this datatype.  If it's locked, nothing happens.
-
-        You shouldn't ordinarily need to call this function; datatype
-        objects are automatically closed when they're deallocated.
-        """
-        if not self._locked:
-            H5Tclose(self.id)
-
-    IF H5PY_18API:
-        
-        def encode(self):
-            """() => STRING
-
-            Serialize an HDF5 type.  Bear in mind you can also use the
-            native Python pickle/unpickle machinery to do this.  The
-            returned string may contain binary values, including NULLs.
-            """
-            cdef size_t nalloc = 0
-            cdef char* buf = NULL
-
-            H5Tencode(self.id, NULL, &nalloc)
-            buf = <char*>emalloc(sizeof(char)*nalloc)
-            try:
-                H5Tencode(self.id, <unsigned char*>buf, &nalloc)
-                pystr = PyString_FromStringAndSize(buf, nalloc)
-            finally:
-                efree(buf)
-
-            return pystr
-
-    IF H5PY_18API:
-        # Enable pickling
-
-        def __reduce__(self):
-            return (type(self), (-1,), self.encode())
-
-        
-        def __setstate__(self, char* state):
-            self.id = H5Tdecode(<unsigned char*>state)
-
-
-# === Top-level classes (inherit directly from TypeID) ========================
-
-cdef class TypeArrayID(TypeID):
-
-    """
-        Represents an array datatype
-    """
-
-    
-    def get_array_ndims(self):
-        """() => INT rank
-
-        Get the rank of the given array datatype.
-        """
-        return H5Tget_array_ndims(self.id)
-
-    
-    def get_array_dims(self):
-        """() => TUPLE dimensions
-
-        Get the dimensions of the given array datatype as
-        a tuple of integers.
-        """
-        cdef hsize_t rank   
-        cdef hsize_t* dims = NULL
-
-        rank = H5Tget_array_dims(self.id, NULL, NULL)
-        dims = <hsize_t*>emalloc(sizeof(hsize_t)*rank)
-        try:
-            H5Tget_array_dims(self.id, dims, NULL)
-            return convert_dims(dims, rank)
-        finally:
-            efree(dims)
-
-    cdef object py_dtype(self):
-        # Numpy translation function for array types
-        cdef TypeID tmp_type
-        tmp_type = self.get_super()
-
-        base_dtype = tmp_type.py_dtype()
-
-        shape = self.get_array_dims()
-        return dtype( (base_dtype, shape) )
-
-
-cdef class TypeOpaqueID(TypeID):
-
-    """
-        Represents an opaque type
-    """
-
-    
-    def set_tag(self, char* tag):
-        """(STRING tag)
-
-        Set a string describing the contents of an opaque datatype.
-        Limited to 256 characters.
-        """
-        H5Tset_tag(self.id, tag)
-
-    
-    def get_tag(self):
-        """() => STRING tag
-
-        Get the tag associated with an opaque datatype.
-        """
-        cdef char* buf = NULL
-
-        try:
-            buf = H5Tget_tag(self.id)
-            assert buf != NULL
-            tag = buf
-            return tag
-        finally:
-            free(buf)
-
-    cdef object py_dtype(self):
-        # Numpy translation function for opaque types
-        return dtype("|V" + str(self.get_size()))
-
-cdef class TypeStringID(TypeID):
-
-    """
-        String datatypes, both fixed and vlen.
-    """
-
-    
-    def is_variable_str(self):
-        """() => BOOL is_variable
-
-        Determine if the given string datatype is a variable-length string.
-        """
-        return <bint>(H5Tis_variable_str(self.id))
-
-    
-    def get_cset(self):
-        """() => INT character_set
-
-        Retrieve the character set used for a string.
-        """
-        return <int>H5Tget_cset(self.id)
-
-    
-    def set_cset(self, int cset):
-        """(INT character_set)
-
-        Set the character set used for a string.
-        """
-        H5Tset_cset(self.id, <H5T_cset_t>cset)
-
-    
-    def get_strpad(self):
-        """() => INT padding_type
-
-        Get the padding type.  Legal values are:
-
-        STR_NULLTERM
-            NULL termination only (C style)
-
-        STR_NULLPAD
-            Pad buffer with NULLs
-
-        STR_SPACEPAD
-            Pad buffer with spaces (FORTRAN style)
-        """
-        return <int>H5Tget_strpad(self.id)
-
-    
-    def set_strpad(self, int pad):
-        """(INT pad)
-
-        Set the padding type.  Legal values are:
-
-        STR_NULLTERM
-            NULL termination only (C style)
-
-        STR_NULLPAD
-            Pad buffer with NULLs
-
-        STR_SPACEPAD
-            Pad buffer with spaces (FORTRAN style)
-        """
-        H5Tset_strpad(self.id, <H5T_str_t>pad)
-
-    cdef object py_dtype(self):
-        # Numpy translation function for string types
-        if self.is_variable_str():
-            return special_dtype(vlen=str)
-
-        return dtype("|S" + str(self.get_size()))
-
-cdef class TypeVlenID(TypeID):
-
-    """
-        Non-string vlen datatypes.
-    """
-    pass
-
-cdef class TypeTimeID(TypeID):
-
-    """
-        Unix-style time_t (deprecated)
-    """
-    pass
-
-cdef class TypeBitfieldID(TypeID):
-
-    """
-        HDF5 bitfield type
-    """
-    pass
-
-cdef class TypeReferenceID(TypeID):
-
-    """
-        HDF5 object or region reference
-    """
+
+#PYTHON_OBJECT = lockid(get_object_type())
+
+# Translation tables for HDF5 -> NumPy dtype conversion
+cdef dict _order_map = { H5T_ORDER_NONE: '|', H5T_ORDER_LE: '<', H5T_ORDER_BE: '>'}
+cdef dict _sign_map  = { H5T_SGN_NONE: 'u', H5T_SGN_2: 'i' }
+
+
+# === General datatype operations =============================================
+
+
+def create(int classtype, size_t size):
+    """(INT classtype, UINT size) => TypeID
+        
+    Create a new HDF5 type object.  Legal class values are 
+    COMPOUND and OPAQUE.  Use enum_create for enums.
+    """
+
+    # HDF5 versions 1.6.X segfault with anything else
+    if classtype != H5T_COMPOUND and classtype != H5T_OPAQUE:
+        raise ValueError("Class must be COMPOUND or OPAQUE.")
+
+    return typewrap(H5Tcreate(<H5T_class_t>classtype, size))
+
+
+def open(ObjectID group not None, char* name):
+    """(ObjectID group, STRING name) => TypeID
+
+    Open a named datatype from a file.
+    """
+    return typewrap(H5Topen(group.id, name))
+
+
+def array_create(TypeID base not None, object dims_tpl):
+    """(TypeID base, TUPLE dimensions) => TypeArrayID
+
+    Create a new array datatype, using and HDF5 parent type and
+    dimensions given via a tuple of positive integers.  "Unlimited" 
+    dimensions are not allowed.
+    """
+    cdef hsize_t rank
+    cdef hsize_t *dims = NULL
+
+    require_tuple(dims_tpl, 0, -1, "dims_tpl")
+    rank = len(dims_tpl)
+    dims = <hsize_t*>emalloc(sizeof(hsize_t)*rank)
+
+    try:
+        convert_tuple(dims_tpl, dims, rank)
+        return TypeArrayID(H5Tarray_create(base.id, rank, dims, NULL))
+    finally:
+        efree(dims)
+
+
+def enum_create(TypeID base not None):
+    """(TypeID base) => TypeID
+
+    Create a new enumerated type based on an (integer) parent type.
+    """
+    return typewrap(H5Tenum_create(base.id))
+
+
+def vlen_create(TypeID base not None):
+    """(TypeID base) => TypeID
+
+    Create a new variable-length datatype, using any HDF5 type as a base.
+
+    Although the Python interface can manipulate these types, there is no
+    provision for reading/writing vlen data.
+    """
+    return typewrap(H5Tvlen_create(base.id))
+
+IF H5PY_18API:
     
+    def decode(char* buf):
+        """(STRING buf) => TypeID
+
+        Unserialize an HDF5 type.  You can also do this with the native
+        Python pickling machinery.
+        """
+        return typewrap(H5Tdecode(<unsigned char*>buf))
+
+# === Base type class =========================================================
+
+cdef class TypeID(ObjectID):
+
+    """
+        Base class for type identifiers (implements common operations)
+
+        * Hashable: If committed; in HDF5 1.8.X, also if locked
+        * Equality: Logical H5T comparison
+    """
+
+    def __hash__(self):
+        if self._hash is None:
+            try:
+                # Try to use object header first
+                return ObjectID.__hash__(self)
+            except TypeError:
+                # It's a transient type object
+                IF H5PY_18API:
+                    if self._locked:
+                        self._hash = hash(self.encode())
+                    else:
+                        raise TypeError("Only locked or committed types can be hashed")
+                ELSE:
+                    raise TypeError("Only committed types can be hashed")
+
+        return self._hash
+
+    def __richcmp__(self, object other, int how):
+        cdef bint truthval = 0
+        if how != 2 and how != 3:
+            return NotImplemented
+        if isinstance(other, TypeID):
+            truthval = self.equal(other)
+        
+        if how == 2:
+            return truthval
+        return not truthval
+
+    def __copy__(self):
+        cdef TypeID cpy
+        cpy = ObjectID.__copy__(self)
+        return cpy
+
+    property dtype:
+        """ A Numpy-style dtype object representing this object.
+        """
+        def __get__(self):
+            return self.py_dtype()
+
     cdef object py_dtype(self):
-        if H5Tequal(self.id, H5T_STD_REF_OBJ):
-            return special_dtype(ref=Reference)
-        elif H5Tequal(self.id, H5T_STD_REF_DSETREG):
-            return special_dtype(ref=RegionReference)
+        raise TypeError("No NumPy equivalent for %s exists" % self.__class__.__name__)
+
+    IF H5PY_18API:
+        
+        def commit(self, ObjectID group not None, char* name, PropID lcpl=None):
+            """(ObjectID group, STRING name, PropID lcpl=None)
+
+            Commit this (transient) datatype to a named datatype in a file.
+            If present, lcpl may be a link creation property list.
+            """
+            H5Tcommit2(group.id, name, self.id, pdefault(lcpl),
+                H5P_DEFAULT, H5P_DEFAULT)
+    ELSE:
+        
+        def commit(self, ObjectID group not None, char* name):
+            """(ObjectID group, STRING name)
+
+            Commit this (transient) datatype to a named datatype in a file.
+            """
+            H5Tcommit(group.id, name, self.id)
+
+    
+    def committed(self):
+        """() => BOOL is_comitted
+
+        Determine if a given type object is named (T) or transient (F).
+        """
+        return <bint>(H5Tcommitted(self.id))
+
+    
+    def copy(self):
+        """() => TypeID
+
+        Create a copy of this type object.
+        """
+        return typewrap(H5Tcopy(self.id))
+
+    
+    def equal(self, TypeID typeid):
+        """(TypeID typeid) => BOOL
+
+        Logical comparison between datatypes.  Also called by
+        Python's "==" operator.
+        """
+        return <bint>(H5Tequal(self.id, typeid.id))
+
+    
+    def lock(self):
+        """()
+
+        Lock this datatype, which makes it immutable and indestructible.
+        Once locked, it can't be unlocked.
+        """
+        H5Tlock(self.id)
+        self._locked = 1
+
+    
+    def get_class(self):
+        """() => INT classcode
+
+        Determine the datatype's class code.
+        """
+        return <int>H5Tget_class(self.id)
+
+    
+    def set_size(self, size_t size):
+        """(UINT size)
+
+        Set the total size of the datatype, in bytes.
+        """
+        H5Tset_size(self.id, size)
+
+    
+    def get_size(self):
+        """ () => INT size
+
+            Determine the total size of a datatype, in bytes.
+        """
+        return H5Tget_size(self.id)
+
+    
+    def get_super(self):
+        """() => TypeID
+
+        Determine the parent type of an array, enumeration or vlen datatype.
+        """
+        return typewrap(H5Tget_super(self.id))
+
+    
+    def detect_class(self, int classtype):
+        """(INT classtype) => BOOL class_is_present
+
+        Determine if a member of the given class exists in a compound
+        datatype.  The search is recursive.
+        """
+        return <bint>(H5Tdetect_class(self.id, <H5T_class_t>classtype))
+
+    
+    def _close(self):
+        """()
+
+        Close this datatype.  If it's locked, nothing happens.
+
+        You shouldn't ordinarily need to call this function; datatype
+        objects are automatically closed when they're deallocated.
+        """
+        if not self._locked:
+            H5Tclose(self.id)
+
+    IF H5PY_18API:
+        
+        def encode(self):
+            """() => STRING
+
+            Serialize an HDF5 type.  Bear in mind you can also use the
+            native Python pickle/unpickle machinery to do this.  The
+            returned string may contain binary values, including NULLs.
+            """
+            cdef size_t nalloc = 0
+            cdef char* buf = NULL
+
+            H5Tencode(self.id, NULL, &nalloc)
+            buf = <char*>emalloc(sizeof(char)*nalloc)
+            try:
+                H5Tencode(self.id, <unsigned char*>buf, &nalloc)
+                pystr = PyString_FromStringAndSize(buf, nalloc)
+            finally:
+                efree(buf)
+
+            return pystr
+
+    IF H5PY_18API:
+        # Enable pickling
+
+        def __reduce__(self):
+            return (type(self), (-1,), self.encode())
+
+        
+        def __setstate__(self, char* state):
+            self.id = H5Tdecode(<unsigned char*>state)
+
+
+# === Top-level classes (inherit directly from TypeID) ========================
+
+cdef class TypeArrayID(TypeID):
+
+    """
+        Represents an array datatype
+    """
+
+    
+    def get_array_ndims(self):
+        """() => INT rank
+
+        Get the rank of the given array datatype.
+        """
+        return H5Tget_array_ndims(self.id)
+
+    
+    def get_array_dims(self):
+        """() => TUPLE dimensions
+
+        Get the dimensions of the given array datatype as
+        a tuple of integers.
+        """
+        cdef hsize_t rank   
+        cdef hsize_t* dims = NULL
+
+        rank = H5Tget_array_dims(self.id, NULL, NULL)
+        dims = <hsize_t*>emalloc(sizeof(hsize_t)*rank)
+        try:
+            H5Tget_array_dims(self.id, dims, NULL)
+            return convert_dims(dims, rank)
+        finally:
+            efree(dims)
+
+    cdef object py_dtype(self):
+        # Numpy translation function for array types
+        cdef TypeID tmp_type
+        tmp_type = self.get_super()
+
+        base_dtype = tmp_type.py_dtype()
+
+        shape = self.get_array_dims()
+        return dtype( (base_dtype, shape) )
+
+
+cdef class TypeOpaqueID(TypeID):
+
+    """
+        Represents an opaque type
+    """
+
+    
+    def set_tag(self, char* tag):
+        """(STRING tag)
+
+        Set a string describing the contents of an opaque datatype.
+        Limited to 256 characters.
+        """
+        H5Tset_tag(self.id, tag)
+
+    
+    def get_tag(self):
+        """() => STRING tag
+
+        Get the tag associated with an opaque datatype.
+        """
+        cdef char* buf = NULL
+
+        try:
+            buf = H5Tget_tag(self.id)
+            assert buf != NULL
+            tag = buf
+            return tag
+        finally:
+            free(buf)
+
+    cdef object py_dtype(self):
+        # Numpy translation function for opaque types
+        return dtype("|V" + str(self.get_size()))
+
+cdef class TypeStringID(TypeID):
+
+    """
+        String datatypes, both fixed and vlen.
+    """
+
+    
+    def is_variable_str(self):
+        """() => BOOL is_variable
+
+        Determine if the given string datatype is a variable-length string.
+        """
+        return <bint>(H5Tis_variable_str(self.id))
+
+    
+    def get_cset(self):
+        """() => INT character_set
+
+        Retrieve the character set used for a string.
+        """
+        return <int>H5Tget_cset(self.id)
+
+    
+    def set_cset(self, int cset):
+        """(INT character_set)
+
+        Set the character set used for a string.
+        """
+        H5Tset_cset(self.id, <H5T_cset_t>cset)
+
+    
+    def get_strpad(self):
+        """() => INT padding_type
+
+        Get the padding type.  Legal values are:
+
+        STR_NULLTERM
+            NULL termination only (C style)
+
+        STR_NULLPAD
+            Pad buffer with NULLs
+
+        STR_SPACEPAD
+            Pad buffer with spaces (FORTRAN style)
+        """
+        return <int>H5Tget_strpad(self.id)
+
+    
+    def set_strpad(self, int pad):
+        """(INT pad)
+
+        Set the padding type.  Legal values are:
+
+        STR_NULLTERM
+            NULL termination only (C style)
+
+        STR_NULLPAD
+            Pad buffer with NULLs
+
+        STR_SPACEPAD
+            Pad buffer with spaces (FORTRAN style)
+        """
+        H5Tset_strpad(self.id, <H5T_str_t>pad)
+
+    cdef object py_dtype(self):
+        # Numpy translation function for string types
+        if self.is_variable_str():
+            return special_dtype(vlen=str)
+
+        return dtype("|S" + str(self.get_size()))
+
+cdef class TypeVlenID(TypeID):
+
+    """
+        Non-string vlen datatypes.
+    """
+    pass
+
+cdef class TypeTimeID(TypeID):
+
+    """
+        Unix-style time_t (deprecated)
+    """
+    pass
+
+cdef class TypeBitfieldID(TypeID):
+
+    """
+        HDF5 bitfield type
+    """
+    pass
+
+cdef class TypeReferenceID(TypeID):
+
+    """
+        HDF5 object or region reference
+    """
+    
+    cdef object py_dtype(self):
+        if H5Tequal(self.id, H5T_STD_REF_OBJ):
+            return special_dtype(ref=Reference)
+        elif H5Tequal(self.id, H5T_STD_REF_DSETREG):
+            return special_dtype(ref=RegionReference)
+        else:
+            raise TypeError("Unknown reference type")
+
+
+# === Numeric classes (integers and floats) ===================================
+
+cdef class TypeAtomicID(TypeID):
+
+    """
+        Base class for atomic datatypes (float or integer)
+    """
+
+    
+    def get_order(self):
+        """() => INT order
+
+        Obtain the byte order of the datatype; one of:
+
+        - ORDER_LE
+        - ORDER_BE
+        """
+        return <int>H5Tget_order(self.id)
+
+    
+    def set_order(self, int order):
+        """(INT order)
+
+        Set the byte order of the datatype; one of:
+
+        - ORDER_LE
+        - ORDER_BE
+        """
+        H5Tset_order(self.id, <H5T_order_t>order)
+
+    
+    def get_precision(self):
+        """() => UINT precision
+
+        Get the number of significant bits (excludes padding).
+        """
+        return H5Tget_precision(self.id)
+
+    
+    def set_precision(self, size_t precision):
+        """(UINT precision)
+            
+        Set the number of significant bits (excludes padding).
+        """
+        H5Tset_precision(self.id, precision)
+
+    
+    def get_offset(self):
+        """() => INT offset
+
+        Get the offset of the first significant bit.
+        """
+        return H5Tget_offset(self.id)
+
+    
+    def set_offset(self, size_t offset):
+        """(UINT offset)
+
+        Set the offset of the first significant bit.
+        """
+        H5Tset_offset(self.id, offset)
+
+    
+    def get_pad(self):
+        """() => (INT lsb_pad_code, INT msb_pad_code)
+
+        Determine the padding type.  Possible values are:
+
+        - PAD_ZERO
+        - PAD_ONE
+        - PAD_BACKGROUND
+        """
+        cdef H5T_pad_t lsb
+        cdef H5T_pad_t msb
+        H5Tget_pad(self.id, &lsb, &msb)
+        return (<int>lsb, <int>msb)
+
+    
+    def set_pad(self, int lsb, int msb):
+        """(INT lsb_pad_code, INT msb_pad_code)
+
+        Set the padding type.  Possible values are:
+
+        - PAD_ZERO
+        - PAD_ONE
+        - PAD_BACKGROUND
+        """
+        H5Tset_pad(self.id, <H5T_pad_t>lsb, <H5T_pad_t>msb)
+
+
+cdef class TypeIntegerID(TypeAtomicID):
+
+    """
+        Integer atomic datatypes
+    """
+
+    
+    def get_sign(self):
+        """() => INT sign
+
+        Get the "signedness" of the datatype; one of:
+
+        SGN_NONE
+            Unsigned
+
+        SGN_2
+            Signed 2's complement
+        """
+        return <int>H5Tget_sign(self.id)
+
+    
+    def set_sign(self, int sign):
+        """(INT sign)
+
+        Set the "signedness" of the datatype; one of:
+
+        SGN_NONE
+            Unsigned
+
+        SGN_2
+            Signed 2's complement
+        """
+        H5Tset_sign(self.id, <H5T_sign_t>sign)
+
+    cdef object py_dtype(self):
+        # Translation function for integer types
+        return dtype( _order_map[self.get_order()] + 
+                      _sign_map[self.get_sign()] + str(self.get_size()) )
+
+
+cdef class TypeFloatID(TypeAtomicID):
+
+    """
+        Floating-point atomic datatypes
+    """
+
+    
+    def get_fields(self):
+        """() => TUPLE field_info
+
+        Get information about floating-point bit fields.  See the HDF5
+        docs for a full description.  Tuple has the following members:
+
+        0. UINT spos
+        1. UINT epos
+        2. UINT esize
+        3. UINT mpos
+        4. UINT msize
+        """
+        cdef size_t spos, epos, esize, mpos, msize
+        H5Tget_fields(self.id, &spos, &epos, &esize, &mpos, &msize)
+        return (spos, epos, esize, mpos, msize)
+
+    
+    def set_fields(self, size_t spos, size_t epos, size_t esize, 
+                          size_t mpos, size_t msize):
+        """(UINT spos, UINT epos, UINT esize, UINT mpos, UINT msize)
+
+        Set floating-point bit fields.  Refer to the HDF5 docs for
+        argument definitions.
+        """
+        H5Tset_fields(self.id, spos, epos, esize, mpos, msize)
+
+    
+    def get_ebias(self):
+        """() => UINT ebias
+
+        Get the exponent bias.
+        """
+        return H5Tget_ebias(self.id)
+
+    
+    def set_ebias(self, size_t ebias):
+        """(UINT ebias)
+
+        Set the exponent bias.
+        """
+        H5Tset_ebias(self.id, ebias)
+
+    
+    def get_norm(self):
+        """() => INT normalization_code
+
+        Get the normalization strategy.  Legal values are:
+
+        - NORM_IMPLIED
+        - NORM_MSBSET
+        - NORM_NONE
+        """
+        return <int>H5Tget_norm(self.id)
+
+    
+    def set_norm(self, int norm):
+        """(INT normalization_code)
+
+        Set the normalization strategy.  Legal values are:
+
+        - NORM_IMPLIED
+        - NORM_MSBSET
+        - NORM_NONE
+        """
+        H5Tset_norm(self.id, <H5T_norm_t>norm)
+
+    
+    def get_inpad(self):
+        """() => INT pad_code
+
+        Determine the internal padding strategy.  Legal values are:
+
+        - PAD_ZERO
+        - PAD_ONE
+        - PAD_BACKGROUND
+        """
+        return <int>H5Tget_inpad(self.id)
+
+    
+    def set_inpad(self, int pad_code):
+        """(INT pad_code)
+
+        Set the internal padding strategy.  Legal values are:
+
+        - PAD_ZERO
+        - PAD_ONE
+        - PAD_BACKGROUND
+        """
+        H5Tset_inpad(self.id, <H5T_pad_t>pad_code)
+
+    cdef object py_dtype(self):
+        # Translation function for floating-point types
+        return dtype( _order_map[self.get_order()] + "f" + \
+                      str(self.get_size()) )
+
+
+# === Composite types (enums and compound) ====================================
+
+cdef class TypeCompositeID(TypeID):
+
+    """
+        Base class for enumerated and compound types.
+    """
+
+    
+    def get_nmembers(self):
+        """() => INT number_of_members
+
+        Determine the number of members in a compound or enumerated type.
+        """
+        return H5Tget_nmembers(self.id)
+
+    
+    def get_member_name(self, int member):
+        """(INT member) => STRING name
+        
+        Determine the name of a member of a compound or enumerated type,
+        identified by its index (0 <= member < nmembers).
+        """
+        cdef char* name
+        name = NULL
+
+        if member < 0:
+            raise ValueError("Member index must be non-negative.")
+
+        try:
+            name = H5Tget_member_name(self.id, member)
+            assert name != NULL
+            pyname = name
+        finally:
+            free(name)
+
+        return pyname
+
+    
+    def get_member_index(self, char* name):
+        """(STRING name) => INT index
+
+        Determine the index of a member of a compound or enumerated datatype
+        identified by a string name.
+        """
+        return H5Tget_member_index(self.id, name)
+
+
+cdef class TypeCompoundID(TypeCompositeID):
+
+    """
+        Represents a compound datatype
+    """
+
+
+    
+    def get_member_class(self, int member):
+        """(INT member) => INT class
+
+        Determine the datatype class of the member of a compound type,
+        identified by its index (0 <= member < nmembers).
+        """
+        if member < 0:
+            raise ValueError("Member index must be non-negative.")
+        return H5Tget_member_class(self.id, member)
+
+
+    
+    def get_member_offset(self, int member):
+        """(INT member) => INT offset
+
+        Determine the offset, in bytes, of the beginning of the specified
+        member of a compound datatype.
+        """
+        if member < 0:
+            raise ValueError("Member index must be non-negative.")
+        return H5Tget_member_offset(self.id, member)
+
+    
+    def get_member_type(self, int member):
+        """(INT member) => TypeID
+
+        Create a copy of a member of a compound datatype, identified by its
+        index.
+        """
+        if member < 0:
+            raise ValueError("Member index must be non-negative.")
+        return typewrap(H5Tget_member_type(self.id, member))
+
+    
+    def insert(self, char* name, size_t offset, TypeID field not None):
+        """(STRING name, UINT offset, TypeID field)
+
+        Add a named member datatype to a compound datatype.  The parameter
+        offset indicates the offset from the start of the compound datatype,
+        in bytes.
+        """
+        H5Tinsert(self.id, name, offset, field.id)
+
+    
+    def pack(self):
+        """()
+
+        Recursively removes padding (introduced on account of e.g. compiler
+        alignment rules) from a compound datatype.
+        """
+        H5Tpack(self.id)
+
+    cdef object py_dtype(self):
+
+        cdef TypeID tmp_type
+        cdef list field_names
+        cdef list field_types
+        cdef int nfields
+        field_names = []
+        field_types = []
+        nfields = self.get_nmembers()
+
+        # First step: read field names and their Numpy dtypes into 
+        # two separate arrays.
+        for i from 0 <= i < nfields:
+            tmp_type = self.get_member_type(i)
+            field_names.append(self.get_member_name(i))
+            field_types.append(tmp_type.py_dtype())
+
+
+        # 1. Check if it should be converted to a complex number
+        if len(field_names) == 2                                and \
+            tuple(field_names) == (cfg._r_name, cfg._i_name)    and \
+            field_types[0] == field_types[1]                    and \
+            field_types[0].kind == 'f':
+
+            bstring = field_types[0].str
+            blen = int(bstring[2:])
+            nstring = bstring[0] + "c" + str(2*blen)
+            typeobj = dtype(nstring)
+
+        # 2. Otherwise, read all fields of the compound type, in HDF5 order.
+        else:
+            typeobj = dtype(zip(field_names, field_types))
+
+        return typeobj
+
+cdef class TypeEnumID(TypeCompositeID):
+
+    """
+        Represents an enumerated type
+    """
+
+    cdef int enum_convert(self, long long *buf, int reverse) except -1:
+        # Convert the long long value in "buf" to the native representation
+        # of this (enumerated) type.  Conversion performed in-place.
+        # Reverse: false => llong->type; true => type->llong
+
+        cdef hid_t basetype
+        cdef H5T_class_t class_code
+
+        class_code = H5Tget_class(self.id)
+        if class_code != H5T_ENUM:
+            raise ValueError("This type (class %d) is not of class ENUM" % class_code)
+
+        basetype = H5Tget_super(self.id)
+        assert basetype > 0
+
+        try:
+            if not reverse:
+                H5Tconvert(H5T_NATIVE_LLONG, basetype, 1, buf, NULL, H5P_DEFAULT)
+            else:
+                H5Tconvert(basetype, H5T_NATIVE_LLONG, 1, buf, NULL, H5P_DEFAULT)
+        finally:
+            H5Tclose(basetype)
+
+    
+    def enum_insert(self, char* name, long long value):
+        """(STRING name, INT/LONG value)
+
+        Define a new member of an enumerated type.  The value will be
+        automatically converted to the base type defined for this enum.  If
+        the conversion results in overflow, the value will be silently 
+        clipped.
+        """
+        cdef long long buf
+
+        buf = value
+        self.enum_convert(&buf, 0)
+        H5Tenum_insert(self.id, name, &buf)
+
+    
+    def enum_nameof(self, long long value):
+        """(LONG value) => STRING name
+
+        Determine the name associated with the given value.  Due to a
+        limitation of the HDF5 library, this can only retrieve names up to
+        1023 characters in length.
+        """
+        cdef herr_t retval
+        cdef char name[1024]
+        cdef long long buf
+
+        buf = value
+        self.enum_convert(&buf, 0)
+        retval = H5Tenum_nameof(self.id, &buf, name, 1024)
+        assert retval >= 0
+        retstring = name
+        return retstring
+
+    
+    def enum_valueof(self, char* name):
+        """(STRING name) => LONG value
+
+        Get the value associated with an enum name.
+        """
+        cdef long long buf
+
+        H5Tenum_valueof(self.id, name, &buf)
+        self.enum_convert(&buf, 1)
+        return buf
+
+    
+    def get_member_value(self, int idx):
+        """(UINT index) => LONG value
+
+        Determine the value for the member at the given zero-based index.
+        """
+        cdef herr_t retval
+        cdef hid_t ptype
+        cdef long long val
+        ptype = 0
+
+        if idx < 0:
+            raise ValueError("Index must be non-negative.")
+
+        H5Tget_member_value(self.id, idx, &val)
+        self.enum_convert(&val, 1)
+        return val
+
+    cdef object py_dtype(self):
+        # Translation function for enum types
+
+        cdef TypeID basetype = self.get_super()
+
+        nmembers = self.get_nmembers()
+        members = {}
+
+        for idx in xrange(nmembers):
+            name = self.get_member_name(idx)
+            val = self.get_member_value(idx) 
+            members[name] = val
+
+        ref = {cfg._f_name: 0, cfg._t_name: 1}
+
+        # Boolean types have priority over standard enums
+        if members == ref:
+            return dtype('bool')
+    
+        return special_dtype(enum=(basetype.py_dtype(), members))
+
+
+# === Translation from NumPy dtypes to HDF5 type objects ======================
+
+# The following series of native-C functions each translate a specific class
+# of NumPy dtype into an HDF5 type object.  The result is guaranteed to be
+# transient and unlocked.
+
+cdef dict _float_le = {4: H5T_IEEE_F32LE, 8: H5T_IEEE_F64LE}
+cdef dict _float_be = {4: H5T_IEEE_F32BE, 8: H5T_IEEE_F64BE}
+cdef dict _float_nt = {4: H5T_NATIVE_FLOAT, 8: H5T_NATIVE_DOUBLE}
+
+cdef dict _int_le = {1: H5T_STD_I8LE, 2: H5T_STD_I16LE, 4: H5T_STD_I32LE, 8: H5T_STD_I64LE}
+cdef dict _int_be = {1: H5T_STD_I8BE, 2: H5T_STD_I16BE, 4: H5T_STD_I32BE, 8: H5T_STD_I64BE}
+cdef dict _int_nt = {1: H5T_NATIVE_INT8, 2: H5T_NATIVE_INT16, 4: H5T_NATIVE_INT32, 8: H5T_NATIVE_INT64}
+
+cdef dict _uint_le = {1: H5T_STD_U8LE, 2: H5T_STD_U16LE, 4: H5T_STD_U32LE, 8: H5T_STD_U64LE}
+cdef dict _uint_be = {1: H5T_STD_U8BE, 2: H5T_STD_U16BE, 4: H5T_STD_U32BE, 8: H5T_STD_U64BE}
+cdef dict _uint_nt = {1: H5T_NATIVE_UINT8, 2: H5T_NATIVE_UINT16, 4: H5T_NATIVE_UINT32, 8: H5T_NATIVE_UINT64} 
+
+cdef TypeFloatID _c_float(dtype dt):
+    # Floats (single and double)
+    cdef hid_t tid
+
+    try:
+        if dt.byteorder == c'<':
+            tid =  _float_le[dt.elsize]
+        elif dt.byteorder == c'>':
+            tid =  _float_be[dt.elsize]
         else:
-            raise TypeError("Unknown reference type")
-
-
-# === Numeric classes (integers and floats) ===================================
-
-cdef class TypeAtomicID(TypeID):
-
-    """
-        Base class for atomic datatypes (float or integer)
-    """
-
-    
-    def get_order(self):
-        """() => INT order
-
-        Obtain the byte order of the datatype; one of:
-
-        - ORDER_LE
-        - ORDER_BE
-        """
-        return <int>H5Tget_order(self.id)
-
-    
-    def set_order(self, int order):
-        """(INT order)
-
-        Set the byte order of the datatype; one of:
-
-        - ORDER_LE
-        - ORDER_BE
-        """
-        H5Tset_order(self.id, <H5T_order_t>order)
-
-    
-    def get_precision(self):
-        """() => UINT precision
-
-        Get the number of significant bits (excludes padding).
-        """
-        return H5Tget_precision(self.id)
-
-    
-    def set_precision(self, size_t precision):
-        """(UINT precision)
-            
-        Set the number of significant bits (excludes padding).
-        """
-        H5Tset_precision(self.id, precision)
-
-    
-    def get_offset(self):
-        """() => INT offset
-
-        Get the offset of the first significant bit.
-        """
-        return H5Tget_offset(self.id)
-
-    
-    def set_offset(self, size_t offset):
-        """(UINT offset)
-
-        Set the offset of the first significant bit.
-        """
-        H5Tset_offset(self.id, offset)
-
-    
-    def get_pad(self):
-        """() => (INT lsb_pad_code, INT msb_pad_code)
-
-        Determine the padding type.  Possible values are:
-
-        - PAD_ZERO
-        - PAD_ONE
-        - PAD_BACKGROUND
-        """
-        cdef H5T_pad_t lsb
-        cdef H5T_pad_t msb
-        H5Tget_pad(self.id, &lsb, &msb)
-        return (<int>lsb, <int>msb)
-
-    
-    def set_pad(self, int lsb, int msb):
-        """(INT lsb_pad_code, INT msb_pad_code)
-
-        Set the padding type.  Possible values are:
-
-        - PAD_ZERO
-        - PAD_ONE
-        - PAD_BACKGROUND
-        """
-        H5Tset_pad(self.id, <H5T_pad_t>lsb, <H5T_pad_t>msb)
-
-
-cdef class TypeIntegerID(TypeAtomicID):
-
-    """
-        Integer atomic datatypes
-    """
-
-    
-    def get_sign(self):
-        """() => INT sign
-
-        Get the "signedness" of the datatype; one of:
-
-        SGN_NONE
-            Unsigned
-
-        SGN_2
-            Signed 2's complement
-        """
-        return <int>H5Tget_sign(self.id)
-
-    
-    def set_sign(self, int sign):
-        """(INT sign)
-
-        Set the "signedness" of the datatype; one of:
-
-        SGN_NONE
-            Unsigned
-
-        SGN_2
-            Signed 2's complement
-        """
-        H5Tset_sign(self.id, <H5T_sign_t>sign)
-
-    cdef object py_dtype(self):
-        # Translation function for integer types
-        return dtype( _order_map[self.get_order()] + 
-                      _sign_map[self.get_sign()] + str(self.get_size()) )
-
-
-cdef class TypeFloatID(TypeAtomicID):
-
-    """
-        Floating-point atomic datatypes
-    """
-
-    
-    def get_fields(self):
-        """() => TUPLE field_info
-
-        Get information about floating-point bit fields.  See the HDF5
-        docs for a full description.  Tuple has the following members:
-
-        0. UINT spos
-        1. UINT epos
-        2. UINT esize
-        3. UINT mpos
-        4. UINT msize
-        """
-        cdef size_t spos, epos, esize, mpos, msize
-        H5Tget_fields(self.id, &spos, &epos, &esize, &mpos, &msize)
-        return (spos, epos, esize, mpos, msize)
-
-    
-    def set_fields(self, size_t spos, size_t epos, size_t esize, 
-                          size_t mpos, size_t msize):
-        """(UINT spos, UINT epos, UINT esize, UINT mpos, UINT msize)
-
-        Set floating-point bit fields.  Refer to the HDF5 docs for
-        argument definitions.
-        """
-        H5Tset_fields(self.id, spos, epos, esize, mpos, msize)
-
-    
-    def get_ebias(self):
-        """() => UINT ebias
-
-        Get the exponent bias.
-        """
-        return H5Tget_ebias(self.id)
-
-    
-    def set_ebias(self, size_t ebias):
-        """(UINT ebias)
-
-        Set the exponent bias.
-        """
-        H5Tset_ebias(self.id, ebias)
-
-    
-    def get_norm(self):
-        """() => INT normalization_code
-
-        Get the normalization strategy.  Legal values are:
-
-        - NORM_IMPLIED
-        - NORM_MSBSET
-        - NORM_NONE
-        """
-        return <int>H5Tget_norm(self.id)
-
-    
-    def set_norm(self, int norm):
-        """(INT normalization_code)
-
-        Set the normalization strategy.  Legal values are:
-
-        - NORM_IMPLIED
-        - NORM_MSBSET
-        - NORM_NONE
-        """
-        H5Tset_norm(self.id, <H5T_norm_t>norm)
-
-    
-    def get_inpad(self):
-        """() => INT pad_code
-
-        Determine the internal padding strategy.  Legal values are:
-
-        - PAD_ZERO
-        - PAD_ONE
-        - PAD_BACKGROUND
-        """
-        return <int>H5Tget_inpad(self.id)
-
-    
-    def set_inpad(self, int pad_code):
-        """(INT pad_code)
-
-        Set the internal padding strategy.  Legal values are:
-
-        - PAD_ZERO
-        - PAD_ONE
-        - PAD_BACKGROUND
-        """
-        H5Tset_inpad(self.id, <H5T_pad_t>pad_code)
-
-    cdef object py_dtype(self):
-        # Translation function for floating-point types
-        return dtype( _order_map[self.get_order()] + "f" + \
-                      str(self.get_size()) )
-
-
-# === Composite types (enums and compound) ====================================
-
-cdef class TypeCompositeID(TypeID):
-
-    """
-        Base class for enumerated and compound types.
-    """
-
-    
-    def get_nmembers(self):
-        """() => INT number_of_members
-
-        Determine the number of members in a compound or enumerated type.
-        """
-        return H5Tget_nmembers(self.id)
-
-    
-    def get_member_name(self, int member):
-        """(INT member) => STRING name
-        
-        Determine the name of a member of a compound or enumerated type,
-        identified by its index (0 <= member < nmembers).
-        """
-        cdef char* name
-        name = NULL
-
-        if member < 0:
-            raise ValueError("Member index must be non-negative.")
-
-        try:
-            name = H5Tget_member_name(self.id, member)
-            assert name != NULL
-            pyname = name
-        finally:
-            free(name)
-
-        return pyname
-
-    
-    def get_member_index(self, char* name):
-        """(STRING name) => INT index
-
-        Determine the index of a member of a compound or enumerated datatype
-        identified by a string name.
-        """
-        return H5Tget_member_index(self.id, name)
-
-
-cdef class TypeCompoundID(TypeCompositeID):
-
-    """
-        Represents a compound datatype
-    """
-
-
-    
-    def get_member_class(self, int member):
-        """(INT member) => INT class
-
-        Determine the datatype class of the member of a compound type,
-        identified by its index (0 <= member < nmembers).
-        """
-        if member < 0:
-            raise ValueError("Member index must be non-negative.")
-        return H5Tget_member_class(self.id, member)
-
-
-    
-    def get_member_offset(self, int member):
-        """(INT member) => INT offset
-
-        Determine the offset, in bytes, of the beginning of the specified
-        member of a compound datatype.
-        """
-        if member < 0:
-            raise ValueError("Member index must be non-negative.")
-        return H5Tget_member_offset(self.id, member)
-
-    
-    def get_member_type(self, int member):
-        """(INT member) => TypeID
-
-        Create a copy of a member of a compound datatype, identified by its
-        index.
-        """
-        if member < 0:
-            raise ValueError("Member index must be non-negative.")
-        return typewrap(H5Tget_member_type(self.id, member))
-
-    
-    def insert(self, char* name, size_t offset, TypeID field not None):
-        """(STRING name, UINT offset, TypeID field)
-
-        Add a named member datatype to a compound datatype.  The parameter
-        offset indicates the offset from the start of the compound datatype,
-        in bytes.
-        """
-        H5Tinsert(self.id, name, offset, field.id)
-
-    
-    def pack(self):
-        """()
-
-        Recursively removes padding (introduced on account of e.g. compiler
-        alignment rules) from a compound datatype.
-        """
-        H5Tpack(self.id)
-
-    cdef object py_dtype(self):
-
-        cdef TypeID tmp_type
-        cdef list field_names
-        cdef list field_types
-        cdef int nfields
-        field_names = []
-        field_types = []
-        nfields = self.get_nmembers()
-
-        # First step: read field names and their Numpy dtypes into 
-        # two separate arrays.
-        for i from 0 <= i < nfields:
-            tmp_type = self.get_member_type(i)
-            field_names.append(self.get_member_name(i))
-            field_types.append(tmp_type.py_dtype())
-
-
-        # 1. Check if it should be converted to a complex number
-        if len(field_names) == 2                                and \
-            tuple(field_names) == (cfg._r_name, cfg._i_name)    and \
-            field_types[0] == field_types[1]                    and \
-            field_types[0].kind == 'f':
-
-            bstring = field_types[0].str
-            blen = int(bstring[2:])
-            nstring = bstring[0] + "c" + str(2*blen)
-            typeobj = dtype(nstring)
-
-        # 2. Otherwise, read all fields of the compound type, in HDF5 order.
-        else:
-            typeobj = dtype(zip(field_names, field_types))
-
-        return typeobj
-
-cdef class TypeEnumID(TypeCompositeID):
-
-    """
-        Represents an enumerated type
-    """
-
-    cdef int enum_convert(self, long long *buf, int reverse) except -1:
-        # Convert the long long value in "buf" to the native representation
-        # of this (enumerated) type.  Conversion performed in-place.
-        # Reverse: false => llong->type; true => type->llong
-
-        cdef hid_t basetype
-        cdef H5T_class_t class_code
-
-        class_code = H5Tget_class(self.id)
-        if class_code != H5T_ENUM:
-            raise ValueError("This type (class %d) is not of class ENUM" % class_code)
-
-        basetype = H5Tget_super(self.id)
-        assert basetype > 0
-
-        try:
-            if not reverse:
-                H5Tconvert(H5T_NATIVE_LLONG, basetype, 1, buf, NULL, H5P_DEFAULT)
-            else:
-                H5Tconvert(basetype, H5T_NATIVE_LLONG, 1, buf, NULL, H5P_DEFAULT)
-        finally:
-            H5Tclose(basetype)
-
-    
-    def enum_insert(self, char* name, long long value):
-        """(STRING name, INT/LONG value)
-
-        Define a new member of an enumerated type.  The value will be
-        automatically converted to the base type defined for this enum.  If
-        the conversion results in overflow, the value will be silently 
-        clipped.
-        """
-        cdef long long buf
-
-        buf = value
-        self.enum_convert(&buf, 0)
-        H5Tenum_insert(self.id, name, &buf)
-
-    
-    def enum_nameof(self, long long value):
-        """(LONG value) => STRING name
-
-        Determine the name associated with the given value.  Due to a
-        limitation of the HDF5 library, this can only retrieve names up to
-        1023 characters in length.
-        """
-        cdef herr_t retval
-        cdef char name[1024]
-        cdef long long buf
-
-        buf = value
-        self.enum_convert(&buf, 0)
-        retval = H5Tenum_nameof(self.id, &buf, name, 1024)
-        assert retval >= 0
-        retstring = name
-        return retstring
-
-    
-    def enum_valueof(self, char* name):
-        """(STRING name) => LONG value
-
-        Get the value associated with an enum name.
-        """
-        cdef long long buf
-
-        H5Tenum_valueof(self.id, name, &buf)
-        self.enum_convert(&buf, 1)
-        return buf
-
-    
-    def get_member_value(self, int idx):
-        """(UINT index) => LONG value
-
-        Determine the value for the member at the given zero-based index.
-        """
-        cdef herr_t retval
-        cdef hid_t ptype
-        cdef long long val
-        ptype = 0
-
-        if idx < 0:
-            raise ValueError("Index must be non-negative.")
-
-        H5Tget_member_value(self.id, idx, &val)
-        self.enum_convert(&val, 1)
-        return val
-
-    cdef object py_dtype(self):
-        # Translation function for enum types
-
-        cdef TypeID basetype = self.get_super()
-
-        nmembers = self.get_nmembers()
-        members = {}
-
-        for idx in xrange(nmembers):
-            name = self.get_member_name(idx)
-            val = self.get_member_value(idx) 
-            members[name] = val
-
-        ref = {cfg._f_name: 0, cfg._t_name: 1}
-
-        # Boolean types have priority over standard enums
-        if members == ref:
-            return dtype('bool')
-    
-        return special_dtype(enum=(basetype.py_dtype(), members))
-
-
-# === Translation from NumPy dtypes to HDF5 type objects ======================
-
-# The following series of native-C functions each translate a specific class
-# of NumPy dtype into an HDF5 type object.  The result is guaranteed to be
-# transient and unlocked.
-
-cdef dict _float_le = {4: H5T_IEEE_F32LE, 8: H5T_IEEE_F64LE}
-cdef dict _float_be = {4: H5T_IEEE_F32BE, 8: H5T_IEEE_F64BE}
-cdef dict _float_nt = {4: H5T_NATIVE_FLOAT, 8: H5T_NATIVE_DOUBLE}
-
-cdef dict _int_le = {1: H5T_STD_I8LE, 2: H5T_STD_I16LE, 4: H5T_STD_I32LE, 8: H5T_STD_I64LE}
-cdef dict _int_be = {1: H5T_STD_I8BE, 2: H5T_STD_I16BE, 4: H5T_STD_I32BE, 8: H5T_STD_I64BE}
-cdef dict _int_nt = {1: H5T_NATIVE_INT8, 2: H5T_NATIVE_INT16, 4: H5T_NATIVE_INT32, 8: H5T_NATIVE_INT64}
-
-cdef dict _uint_le = {1: H5T_STD_U8LE, 2: H5T_STD_U16LE, 4: H5T_STD_U32LE, 8: H5T_STD_U64LE}
-cdef dict _uint_be = {1: H5T_STD_U8BE, 2: H5T_STD_U16BE, 4: H5T_STD_U32BE, 8: H5T_STD_U64BE}
-cdef dict _uint_nt = {1: H5T_NATIVE_UINT8, 2: H5T_NATIVE_UINT16, 4: H5T_NATIVE_UINT32, 8: H5T_NATIVE_UINT64} 
-
-cdef TypeFloatID _c_float(dtype dt):
-    # Floats (single and double)
-    cdef hid_t tid
-
-    try:
-        if dt.byteorder == c'<':
-            tid =  _float_le[dt.elsize]
-        elif dt.byteorder == c'>':
-            tid =  _float_be[dt.elsize]
-        else:
-            tid =  _float_nt[dt.elsize]
+            tid =  _float_nt[dt.elsize]
     except KeyError:
         raise TypeError("Unsupported float size (%s)" % dt.elsize)
-
-    return TypeFloatID(H5Tcopy(tid))
-
-cdef TypeIntegerID _c_int(dtype dt):
-    # Integers (ints and uints)
-    cdef hid_t tid
-
-    try:
-        if dt.kind == c'i':
-            if dt.byteorder == c'<':
-                tid = _int_le[dt.elsize]
-            elif dt.byteorder == c'>':
-                tid = _int_be[dt.elsize]
-            else:
-                tid = _int_nt[dt.elsize]
-        elif dt.kind == c'u':
-            if dt.byteorder == c'<':
-                tid = _uint_le[dt.elsize]
-            elif dt.byteorder == c'>':
-                tid = _uint_be[dt.elsize]
-            else:
-                tid = _uint_nt[dt.elsize]
-        else:
-            raise TypeError('Illegal int kind "%s"' % dt.kind)
+
+    return TypeFloatID(H5Tcopy(tid))
+
+cdef TypeIntegerID _c_int(dtype dt):
+    # Integers (ints and uints)
+    cdef hid_t tid
+
+    try:
+        if dt.kind == c'i':
+            if dt.byteorder == c'<':
+                tid = _int_le[dt.elsize]
+            elif dt.byteorder == c'>':
+                tid = _int_be[dt.elsize]
+            else:
+                tid = _int_nt[dt.elsize]
+        elif dt.kind == c'u':
+            if dt.byteorder == c'<':
+                tid = _uint_le[dt.elsize]
+            elif dt.byteorder == c'>':
+                tid = _uint_be[dt.elsize]
+            else:
+                tid = _uint_nt[dt.elsize]
+        else:
+            raise TypeError('Illegal int kind "%s"' % dt.kind)
     except KeyError:
         raise TypeError("Unsupported integer size (%s)" % dt.elsize)
-
-    return TypeIntegerID(H5Tcopy(tid))
-
-cdef TypeEnumID _c_enum(dtype dt, dict vals):
-    # Enums
-    cdef TypeIntegerID base
-    cdef TypeEnumID out
-
-    base = _c_int(dt)
-
-    out = TypeEnumID(H5Tenum_create(base.id))
-    for name in sorted(vals):
-        out.enum_insert(name, vals[name])
-    return out
-
-cdef TypeEnumID _c_bool(dtype dt):
-    # Booleans
-    global cfg
-
-    cdef TypeEnumID out
-    out = TypeEnumID(H5Tenum_create(H5T_NATIVE_INT8))
-
-    out.enum_insert(cfg._f_name, 0)
-    out.enum_insert(cfg._t_name, 1)
-
-    return out
-
-cdef TypeArrayID _c_array(dtype dt, int logical):
-    # Arrays
-    cdef dtype base
-    cdef TypeID type_base
-    cdef object shape
-
+
+    return TypeIntegerID(H5Tcopy(tid))
+
+cdef TypeEnumID _c_enum(dtype dt, dict vals):
+    # Enums
+    cdef TypeIntegerID base
+    cdef TypeEnumID out
+
+    base = _c_int(dt)
+
+    out = TypeEnumID(H5Tenum_create(base.id))
+    for name in sorted(vals):
+        out.enum_insert(name, vals[name])
+    return out
+
+cdef TypeEnumID _c_bool(dtype dt):
+    # Booleans
+    global cfg
+
+    cdef TypeEnumID out
+    out = TypeEnumID(H5Tenum_create(H5T_NATIVE_INT8))
+
+    out.enum_insert(cfg._f_name, 0)
+    out.enum_insert(cfg._t_name, 1)
+
+    return out
+
+cdef TypeArrayID _c_array(dtype dt, int logical):
+    # Arrays
+    cdef dtype base
+    cdef TypeID type_base
+    cdef object shape
+
     base, shape = dt.subdtype
     try:
         shape = tuple(shape)
@@ -1248,88 +1248,88 @@ cdef TypeArrayID _c_array(dtype dt, int logical):
         try:
             shape = (int(shape),)
         except TypeError:
-            raise TypeError("Array shape for dtype must be a sequence or integer")
-    type_base = py_create(base, logical=logical)
-    return array_create(type_base, shape)
-
-cdef TypeOpaqueID _c_opaque(dtype dt):
-    # Opaque
-    return TypeOpaqueID(H5Tcreate(H5T_OPAQUE, dt.itemsize))
-
-cdef TypeStringID _c_string(dtype dt):
-    # Strings (fixed-length)
-    cdef hid_t tid
-
-    tid = H5Tcopy(H5T_C_S1)
-    H5Tset_size(tid, dt.itemsize)
-    H5Tset_strpad(tid, H5T_STR_NULLPAD)
-    return TypeStringID(tid)
-
-cdef TypeCompoundID _c_complex(dtype dt):
-    # Complex numbers (names depend on cfg)
-    global cfg
-
-    cdef hid_t tid, tid_sub
-    cdef size_t size, off_r, off_i
-
-    cdef size_t length = dt.itemsize
-    cdef char byteorder = dt.byteorder
-
-    if length == 8:
-        size = h5py_size_n64
-        off_r = h5py_offset_n64_real
-        off_i = h5py_offset_n64_imag
-        if byteorder == c'<':
-            tid_sub = H5T_IEEE_F32LE
-        elif byteorder == c'>':
-            tid_sub = H5T_IEEE_F32BE
-        else:
-            tid_sub = H5T_NATIVE_FLOAT
-    elif length == 16:
-        size = h5py_size_n128
-        off_r = h5py_offset_n128_real
-        off_i = h5py_offset_n128_imag
-        if byteorder == c'<':
-            tid_sub = H5T_IEEE_F64LE
-        elif byteorder == c'>':
-            tid_sub = H5T_IEEE_F64BE
-        else:
-            tid_sub = H5T_NATIVE_DOUBLE
-    else:
-        raise TypeError("Illegal length %d for complex dtype" % length)
-
-    tid = H5Tcreate(H5T_COMPOUND, size)
-    H5Tinsert(tid, cfg._r_name, off_r, tid_sub)
-    H5Tinsert(tid, cfg._i_name, off_i, tid_sub)
-
-    return TypeCompoundID(tid)
-
-cdef TypeCompoundID _c_compound(dtype dt, int logical):
-    # Compound datatypes
-
-    cdef hid_t tid
-    cdef TypeID type_tmp
-    cdef dtype dt_tmp
-    cdef size_t offset
-
-    cdef dict fields = dt.fields
-    cdef tuple names = dt.names
-
-    tid = H5Tcreate(H5T_COMPOUND, dt.itemsize)
-
-    for name in names:
-        dt_tmp, offset = dt.fields[name]
-        type_tmp = py_create(dt_tmp, logical=logical)
-        H5Tinsert(tid, name, offset, type_tmp.id)
-
-    return TypeCompoundID(tid)
-
-cdef TypeStringID _c_vlen_str(object basetype):
-    # Variable-length strings
-    cdef hid_t tid
-    tid = H5Tcopy(H5T_C_S1)
-    H5Tset_size(tid, H5T_VARIABLE)
-    return TypeStringID(tid)
+            raise TypeError("Array shape for dtype must be a sequence or integer")
+    type_base = py_create(base, logical=logical)
+    return array_create(type_base, shape)
+
+cdef TypeOpaqueID _c_opaque(dtype dt):
+    # Opaque
+    return TypeOpaqueID(H5Tcreate(H5T_OPAQUE, dt.itemsize))
+
+cdef TypeStringID _c_string(dtype dt):
+    # Strings (fixed-length)
+    cdef hid_t tid
+
+    tid = H5Tcopy(H5T_C_S1)
+    H5Tset_size(tid, dt.itemsize)
+    H5Tset_strpad(tid, H5T_STR_NULLPAD)
+    return TypeStringID(tid)
+
+cdef TypeCompoundID _c_complex(dtype dt):
+    # Complex numbers (names depend on cfg)
+    global cfg
+
+    cdef hid_t tid, tid_sub
+    cdef size_t size, off_r, off_i
+
+    cdef size_t length = dt.itemsize
+    cdef char byteorder = dt.byteorder
+
+    if length == 8:
+        size = h5py_size_n64
+        off_r = h5py_offset_n64_real
+        off_i = h5py_offset_n64_imag
+        if byteorder == c'<':
+            tid_sub = H5T_IEEE_F32LE
+        elif byteorder == c'>':
+            tid_sub = H5T_IEEE_F32BE
+        else:
+            tid_sub = H5T_NATIVE_FLOAT
+    elif length == 16:
+        size = h5py_size_n128
+        off_r = h5py_offset_n128_real
+        off_i = h5py_offset_n128_imag
+        if byteorder == c'<':
+            tid_sub = H5T_IEEE_F64LE
+        elif byteorder == c'>':
+            tid_sub = H5T_IEEE_F64BE
+        else:
+            tid_sub = H5T_NATIVE_DOUBLE
+    else:
+        raise TypeError("Illegal length %d for complex dtype" % length)
+
+    tid = H5Tcreate(H5T_COMPOUND, size)
+    H5Tinsert(tid, cfg._r_name, off_r, tid_sub)
+    H5Tinsert(tid, cfg._i_name, off_i, tid_sub)
+
+    return TypeCompoundID(tid)
+
+cdef TypeCompoundID _c_compound(dtype dt, int logical):
+    # Compound datatypes
+
+    cdef hid_t tid
+    cdef TypeID type_tmp
+    cdef dtype dt_tmp
+    cdef size_t offset
+
+    cdef dict fields = dt.fields
+    cdef tuple names = dt.names
+
+    tid = H5Tcreate(H5T_COMPOUND, dt.itemsize)
+
+    for name in names:
+        dt_tmp, offset = dt.fields[name]
+        type_tmp = py_create(dt_tmp, logical=logical)
+        H5Tinsert(tid, name, offset, type_tmp.id)
+
+    return TypeCompoundID(tid)
+
+cdef TypeStringID _c_vlen_str(object basetype):
+    # Variable-length strings
+    cdef hid_t tid
+    tid = H5Tcopy(H5T_C_S1)
+    H5Tset_size(tid, H5T_VARIABLE)
+    return TypeStringID(tid)
 
 cdef TypeReferenceID _c_ref(object refclass):
     if refclass is Reference:
@@ -1337,84 +1337,84 @@ cdef TypeReferenceID _c_ref(object refclass):
     elif refclass is RegionReference:
         return STD_REF_DSETREG
     raise TypeError("Unrecognized reference code")
+
+cpdef TypeID py_create(object dtype_in, bint logical=0):
+    """(OBJECT dtype_in, BOOL logical=False) => TypeID
+
+    Given a Numpy dtype object, generate a byte-for-byte memory-compatible
+    HDF5 datatype object.  The result is guaranteed to be transient and
+    unlocked.
+
+    Argument dtype_in may be a dtype object, or anything which can be
+    converted to a dtype, including strings like '<i4'.
+
+    logical
+        If this flag is set, instead of returning a byte-for-byte identical
+        representation of the type, the function returns the closest logically
+        appropriate HDF5 type.  For example, in the case of a "hinted" dtype
+        of kind "O" representing a string, it would return an HDF5 variable-
+        length string type.
+    """
+    cdef dtype dt = dtype(dtype_in)
+    cdef char kind = dt.kind
 
-cpdef TypeID py_create(object dtype_in, bint logical=0):
-    """(OBJECT dtype_in, BOOL logical=False) => TypeID
-
-    Given a Numpy dtype object, generate a byte-for-byte memory-compatible
-    HDF5 datatype object.  The result is guaranteed to be transient and
-    unlocked.
-
-    Argument dtype_in may be a dtype object, or anything which can be
-    converted to a dtype, including strings like '<i4'.
-
-    logical
-        If this flag is set, instead of returning a byte-for-byte identical
-        representation of the type, the function returns the closest logically
-        appropriate HDF5 type.  For example, in the case of a "hinted" dtype
-        of kind "O" representing a string, it would return an HDF5 variable-
-        length string type.
-    """
-    cdef dtype dt = dtype(dtype_in)
-    cdef char kind = dt.kind
-

-    # Float
-    if kind == c'f':
-        return _c_float(dt)
-    
-    # Integer
-    elif kind == c'u' or kind == c'i':
-
-        if logical:
-            # Check for an enumeration hint
-            enum_vals = check_dtype(enum=dt)
-            if enum_vals is not None:
-                return _c_enum(dt, enum_vals)
-
-        return _c_int(dt)
-
-    # Complex
-    elif kind == c'c':
-        return _c_complex(dt)
-
-    # Compound
-    elif kind == c'V' and dt.names is not None:
-        return _c_compound(dt, logical)
-
-    # Array or opaque
-    elif kind == c'V':
-        if dt.subdtype is not None:
-            return _c_array(dt, logical)
-        else:
-            return _c_opaque(dt)
-
-    # String
-    elif kind == c'S':
-        return _c_string(dt)
-
-    # Boolean
-    elif kind == c'b':
-        return _c_bool(dt)
-
-    # Object types (including those with vlen hints)
-    elif kind == c'O':
+    # Float
+    if kind == c'f':
+        return _c_float(dt)
+    
+    # Integer
+    elif kind == c'u' or kind == c'i':
+
+        if logical:
+            # Check for an enumeration hint
+            enum_vals = check_dtype(enum=dt)
+            if enum_vals is not None:
+                return _c_enum(dt, enum_vals)
+
+        return _c_int(dt)
+
+    # Complex
+    elif kind == c'c':
+        return _c_complex(dt)
+
+    # Compound
+    elif kind == c'V' and dt.names is not None:
+        return _c_compound(dt, logical)
+
+    # Array or opaque
+    elif kind == c'V':
+        if dt.subdtype is not None:
+            return _c_array(dt, logical)
+        else:
+            return _c_opaque(dt)
 
-        if logical:
-            vlen = check_dtype(vlen=dt)
-            if vlen is not None:
+    # String
+    elif kind == c'S':
+        return _c_string(dt)
+
+    # Boolean
+    elif kind == c'b':
+        return _c_bool(dt)
+
+    # Object types (including those with vlen hints)
+    elif kind == c'O':
+
+        if logical:
+            vlen = check_dtype(vlen=dt)
+            if vlen is not None:
                 return _c_vlen_str(vlen)
 
             refclass = check_dtype(ref=dt)
             if refclass is not None:
                     return _c_ref(refclass)
-
+
             raise TypeError("Object dtype %r has no native HDF5 equivalent" % (dt,))
 
         return PYTHON_OBJECT
-
-    # Unrecognized
-    else:
-        raise TypeError("No conversion path for dtype: %s" % repr(dt))
+
+    # Unrecognized
+    else:
+        raise TypeError("No conversion path for dtype: %s" % repr(dt))
 
 def special_dtype(**kwds):
     """ Create a new h5py "special" type.  Only one keyword may be given.
@@ -1442,9 +1442,9 @@ def special_dtype(**kwds):
     name, val = kwds.popitem()
 
     if name == 'vlen':
-        if val is not str:
+        if val is not str:
             raise NotImplementedError("Only string vlens are currently supported")
-
+
         return dtype(('O', [( ({'type': val},'vlen'), 'O' )] ))
 
     if name == 'enum':
@@ -1454,10 +1454,10 @@ def special_dtype(**kwds):
         except TypeError:
             raise TypeError("Enums must be created from a 2-tuple (basetype, values_dict)")
 
-        dt = dtype(dt)
-        if dt.kind not in "iu":
-            raise TypeError("Only integer types can be used as enums")
-
+        dt = dtype(dt)
+        if dt.kind not in "iu":
+            raise TypeError("Only integer types can be used as enums")
+
         return dtype((dt, [( ({'vals': enum_vals},'enum'), dt )] ))
 
     if name == 'ref':
@@ -1499,15 +1499,15 @@ def check_dtype(**kwds):
 
     hintkey = 'type' if name is not 'enum' else 'vals'
 
-    if dt.fields is not None and name in dt.fields:
-        tpl = dt.fields[name]
-        if len(tpl) == 3:
-            hint_dict = tpl[2]
-            if hintkey in hint_dict:
+    if dt.fields is not None and name in dt.fields:
+        tpl = dt.fields[name]
+        if len(tpl) == 3:
+            hint_dict = tpl[2]
+            if hintkey in hint_dict:
                 return hint_dict[hintkey]
 
-    return None
-
+    return None
+
 def convert(TypeID src not None, TypeID dst not None, size_t n,
             ndarray buf not None, ndarray bkg=None, PropID dxpl=None):
     """ (TypeID src, TypeID dst, UINT n, NDARRAY buf, NDARRAY bkg=None,
@@ -1528,8 +1528,8 @@ def convert(TypeID src not None, TypeID dst not None, size_t n,
         bkg_ = bkg.data
 
     H5Tconvert(src.id, dst.id, n, buf_, bkg_, pdefault(dxpl))
-
-def find(TypeID src not None, TypeID dst not None):
+
+def find(TypeID src not None, TypeID dst not None):
     """ (TypeID src, TypeID dst) => TUPLE or None
 
     Determine if a conversion path exists from src to dst.  Result is None
@@ -1537,53 +1537,53 @@ def find(TypeID src not None, TypeID dst not None):
 
     1. INT need_bkg:    Whether this routine requires a backing buffer.
                         Values are BKG_NO, BKG_TEMP and BKG_YES.
-    """
-    cdef H5T_cdata_t *data
-    cdef H5T_conv_t result = NULL
+    """
+    cdef H5T_cdata_t *data
+    cdef H5T_conv_t result = NULL
     
-    try:
+    try:
         result = H5Tfind(src.id, dst.id, &data)
         if result == NULL:
             return None
-        return (data[0].need_bkg,)
+        return (data[0].need_bkg,)
     except:
-        return None
+        return None
 
 # ============================================================================
 # Deprecated functions
 
 import warnings
-
-cpdef dtype py_new_enum(object dt_in, dict enum_vals):
+
+cpdef dtype py_new_enum(object dt_in, dict enum_vals):
     """ (DTYPE dt_in, DICT enum_vals) => DTYPE
 
-    Deprecated; use special_dtype() instead.
+    Deprecated; use special_dtype() instead.
     """
     #warnings.warn("Deprecated; use special_dtype(enum=(dtype, values)) instead", DeprecationWarning)
     return special_dtype(enum = (dt_in, enum_vals))
-
-cpdef dict py_get_enum(object dt):
-    """ (DTYPE dt_in) => DICT
 
-    Deprecated; use check_dtype() instead.
-    """
-    #warnings.warn("Deprecated; use check_dtype(enum=dtype) instead", DeprecationWarning)
+cpdef dict py_get_enum(object dt):
+    """ (DTYPE dt_in) => DICT
+
+    Deprecated; use check_dtype() instead.
+    """
+    #warnings.warn("Deprecated; use check_dtype(enum=dtype) instead", DeprecationWarning)
     return check_dtype(enum=dt)
-
-cpdef dtype py_new_vlen(object kind):
-    """ (OBJECT kind) => DTYPE
-
-    Deprecated; use special_dtype() instead.
+
+cpdef dtype py_new_vlen(object kind):
+    """ (OBJECT kind) => DTYPE
+
+    Deprecated; use special_dtype() instead.
     """
-    #warnings.warn("Deprecated; use special_dtype(vlen=basetype) instead", DeprecationWarning)
-    return special_dtype(vlen=kind)
-
-cpdef object py_get_vlen(object dt_in):
-    """ (OBJECT dt_in) => TYPE
+    #warnings.warn("Deprecated; use special_dtype(vlen=basetype) instead", DeprecationWarning)
+    return special_dtype(vlen=kind)
+
+cpdef object py_get_vlen(object dt_in):
+    """ (OBJECT dt_in) => TYPE
 
-    Deprecated; use check_dtype() instead.
+    Deprecated; use check_dtype() instead.
     """
-    #warnings.warn("Deprecated; use check_dtype(vlen=dtype) instead", DeprecationWarning)
+    #warnings.warn("Deprecated; use check_dtype(vlen=dtype) instead", DeprecationWarning)
     return check_dtype(vlen=dt_in)
-
-
+
+

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/h5py.git



More information about the debian-science-commits mailing list