np-struct 0.0.2__tar.gz → 0.0.4__tar.gz

{np_struct-0.0.2 → np_struct-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: np-struct
-Version: 0.0.2
+Version: 0.0.4
 Summary: Interface for NumPy structured arrays
 Author-email: Rick Lyon <rlyon14@gmail.com>
 Project-URL: repository, https://github.com/ricklyon/np_struct
@@ -18,9 +18,9 @@ Requires-Dist: pytest; extra == "dev"
 
 # np-struct
 
-`np-struct` extends structured arrays in NumPy to be a bit more user friendly and intuitive, with added support for transferring structured arrays across serial or socket interfaces. 
+`np-struct` is a user friendly interface to NumPy structured arrays, with added support for transferring arrays across interfaces.
  
-Structured arrays are built to mirror the struct typedef in C/C++, but can be used for any complicated data structure. They behave similar to standard arrays, but support mixed data types, labeling, and unequal length arrays. Arrays are easily written or loaded from disk in the standard `.npy` binary format.
+The `Struct` type is designed to mirror the struct typedef in C, but can be used for any complicated data structure. They behave similar to the standard `ndarray`, but support mixed data types, bitfields, labeling, and variable length arrays. Arrays are easily written or loaded from disk in the standard `.npy` binary format.
 
 ## Installation
 
@@ -38,7 +38,7 @@ import numpy as np
 
 ### Structures
 
-Create a c-style structure with Numpy types.
+Create a C-style structure with Numpy types.
 
 ```python
 class example(Struct):
@@ -55,23 +55,20 @@ ex[0].data2 = 1 + 2j
 >>> ex
 Struct example: (3,)
 [
-    psize:  uint16[0]
     data1:  uint32[0]
     data2:  complex128[1.+2.j 1.+2.j 1.+2.j]
 ]
 ...
 [
-    psize:  uint16[0]
     data1:  uint32[0]
     data2:  complex128[0.+0.j 0.+0.j 0.+0.j]
 ]
 ```
 
-Members can also be initialized by passing in their name to the constructor with an inital value. 
+Members can also be initialized by passing in their name to the constructor with an initial value. 
 ```python
 >>> example(data2 = np.zeros(shape=(3,2)))
 Struct example: 
-    psize:  uint16[0]
     data1:  uint32[0]
     data2:  complex128[[0.+0.j 0.+0.j]
 	       [0.+0.j 0.+0.j]
@@ -79,36 +76,49 @@ Struct example:
 ```
 
 The structure inherits from np.ndarray and supports all math functions that a normal structured array does.
-To cast as a standard numpy array:
+To cast as a standard numpy structured array,
 
 ```python
->>>  ex2.view(np.ndarray)
-array([([0], [0], [[0.+0.j, 0.+0.j], [0.+0.j, 0.+0.j], [0.+0.j, 0.+0.j]])],
-      dtype=[('psize', '<u2', (1,)), ('data1', '<u4', (1,)), ('data2', '<c16', (3, 2))])
+>>>  ex.view(np.ndarray)
+array([([0], [0.+0.j, 0.+0.j, 0.+0.j]), ([0], [0.+0.j, 0.+0.j, 0.+0.j]),
+       ([0], [0.+0.j, 0.+0.j, 0.+0.j])],
+      dtype=[('data1', '<u4', (1,)), ('data2', '<c16', (3,))])
 ```
 
-Nested structures are also supported:
+Nested structures are also supported,
 ```python
 class nested(Struct):
     field1 = example()
     field2 = example()
 
 n = nested()
-n.field1.data2 += j*np.pi
+n.field1.data2 += 1j*np.pi
 ```
 ```bash
 >>> n
 Struct nested: 
     field1:  Struct example: 
-              psize:  uint16[0]
               data1:  uint32[0]
               data2:  complex128[0.+3.14159265j 0.+3.14159265j 0.+3.14159265j]
     field2:  Struct example: 
-              psize:  uint16[0]
               data1:  uint32[0]
               data2:  complex128[0.+0.j 0.+0.j 0.+0.j]
 ```
 
+To save to disk,
+```python
+n = nested(shape=2)
+n[1].field2.data1 = 3
+np.save("test.npy", n)
+n_disk = nested(np.load("test.npy"))
+```
+```python
+>>> n_disk.field2.data1
+array([[[0]],
+
+       [[3]]], dtype=uint32)
+```
+
 ### Labeled Arrays
 
 `np-struct` implements a very scaled down version of [Xarray](https://docs.xarray.dev/en/stable/) DataArrays. 
@@ -116,10 +126,9 @@ Struct nested:
 written to disk in the standard `.npy` binary format, and supports indexing with coordinates. 
 
 Math operations that change the coordinates or array shape (i.e. sum or transpose) silently revert the labeled array 
-to a standard numpy array without coordinates.
+to a standard numpy array without coordinates. `np-struct` leaves it up to the user to re-cast the array as an
+`ldarray` with the appropriate coordinates.
 
-Real or complex-valued arrays can be saved with the ``ldarray.save()`` method, and
-loaded with the ``ldarray.load()`` class function.
 
 ```python
 >>> from np_struct import ldarray
@@ -165,8 +174,9 @@ Coordinates: (2,)
   a: ['data1' 'data2']
 ```
 
-Arrays can be written to disk uses the normal numpy methods if the coordinates are not needed, or, to keep the coords,
-use `ldarray.save()` and `load()`. Array is stored as a structured array in the usual `.npy` binary format.
+Real or complex-valued arrays can be written to disk uses the normal numpy methods if the coordinates are not needed, 
+or, to keep the coords, use `ldarray.save()` and `load()`. Array is stored as a structured array in the usual 
+`.npy` binary format.
 ```python
 ld.save("ld_file.npy")
 ldarray.load("ld_file.npy")
@@ -174,7 +184,7 @@ ldarray.load("ld_file.npy")
 
 ## Examples
 
-[Transfering structures over an interface](./examples/structures.ipynb)  
+[Struct example](./examples/structures.ipynb)  
 
 
 ## License

{np_struct-0.0.2 → np_struct-0.0.4}/README.md

@@ -1,8 +1,8 @@
 # np-struct
 
-`np-struct` extends structured arrays in NumPy to be a bit more user friendly and intuitive, with added support for transferring structured arrays across serial or socket interfaces. 
+`np-struct` is a user friendly interface to NumPy structured arrays, with added support for transferring arrays across interfaces.
  
-Structured arrays are built to mirror the struct typedef in C/C++, but can be used for any complicated data structure. They behave similar to standard arrays, but support mixed data types, labeling, and unequal length arrays. Arrays are easily written or loaded from disk in the standard `.npy` binary format.
+The `Struct` type is designed to mirror the struct typedef in C, but can be used for any complicated data structure. They behave similar to the standard `ndarray`, but support mixed data types, bitfields, labeling, and variable length arrays. Arrays are easily written or loaded from disk in the standard `.npy` binary format.
 
 ## Installation
 
@@ -20,7 +20,7 @@ import numpy as np
 
 ### Structures
 
-Create a c-style structure with Numpy types.
+Create a C-style structure with Numpy types.
 
 ```python
 class example(Struct):
@@ -37,23 +37,20 @@ ex[0].data2 = 1 + 2j
 >>> ex
 Struct example: (3,)
 [
-    psize:  uint16[0]
     data1:  uint32[0]
     data2:  complex128[1.+2.j 1.+2.j 1.+2.j]
 ]
 ...
 [
-    psize:  uint16[0]
     data1:  uint32[0]
     data2:  complex128[0.+0.j 0.+0.j 0.+0.j]
 ]
 ```
 
-Members can also be initialized by passing in their name to the constructor with an inital value. 
+Members can also be initialized by passing in their name to the constructor with an initial value. 
 ```python
 >>> example(data2 = np.zeros(shape=(3,2)))
 Struct example: 
-    psize:  uint16[0]
     data1:  uint32[0]
     data2:  complex128[[0.+0.j 0.+0.j]
 	       [0.+0.j 0.+0.j]
@@ -61,36 +58,49 @@ Struct example:
 ```
 
 The structure inherits from np.ndarray and supports all math functions that a normal structured array does.
-To cast as a standard numpy array:
+To cast as a standard numpy structured array,
 
 ```python
->>>  ex2.view(np.ndarray)
-array([([0], [0], [[0.+0.j, 0.+0.j], [0.+0.j, 0.+0.j], [0.+0.j, 0.+0.j]])],
-      dtype=[('psize', '<u2', (1,)), ('data1', '<u4', (1,)), ('data2', '<c16', (3, 2))])
+>>>  ex.view(np.ndarray)
+array([([0], [0.+0.j, 0.+0.j, 0.+0.j]), ([0], [0.+0.j, 0.+0.j, 0.+0.j]),
+       ([0], [0.+0.j, 0.+0.j, 0.+0.j])],
+      dtype=[('data1', '<u4', (1,)), ('data2', '<c16', (3,))])
 ```
 
-Nested structures are also supported:
+Nested structures are also supported,
 ```python
 class nested(Struct):
     field1 = example()
     field2 = example()
 
 n = nested()
-n.field1.data2 += j*np.pi
+n.field1.data2 += 1j*np.pi
 ```
 ```bash
 >>> n
 Struct nested: 
     field1:  Struct example: 
-              psize:  uint16[0]
               data1:  uint32[0]
               data2:  complex128[0.+3.14159265j 0.+3.14159265j 0.+3.14159265j]
     field2:  Struct example: 
-              psize:  uint16[0]
               data1:  uint32[0]
               data2:  complex128[0.+0.j 0.+0.j 0.+0.j]
 ```
 
+To save to disk,
+```python
+n = nested(shape=2)
+n[1].field2.data1 = 3
+np.save("test.npy", n)
+n_disk = nested(np.load("test.npy"))
+```
+```python
+>>> n_disk.field2.data1
+array([[[0]],
+
+       [[3]]], dtype=uint32)
+```
+
 ### Labeled Arrays
 
 `np-struct` implements a very scaled down version of [Xarray](https://docs.xarray.dev/en/stable/) DataArrays. 
@@ -98,10 +108,9 @@ Struct nested:
 written to disk in the standard `.npy` binary format, and supports indexing with coordinates. 
 
 Math operations that change the coordinates or array shape (i.e. sum or transpose) silently revert the labeled array 
-to a standard numpy array without coordinates.
+to a standard numpy array without coordinates. `np-struct` leaves it up to the user to re-cast the array as an
+`ldarray` with the appropriate coordinates.
 
-Real or complex-valued arrays can be saved with the ``ldarray.save()`` method, and
-loaded with the ``ldarray.load()`` class function.
 
 ```python
 >>> from np_struct import ldarray
@@ -147,8 +156,9 @@ Coordinates: (2,)
   a: ['data1' 'data2']
 ```
 
-Arrays can be written to disk uses the normal numpy methods if the coordinates are not needed, or, to keep the coords,
-use `ldarray.save()` and `load()`. Array is stored as a structured array in the usual `.npy` binary format.
+Real or complex-valued arrays can be written to disk uses the normal numpy methods if the coordinates are not needed, 
+or, to keep the coords, use `ldarray.save()` and `load()`. Array is stored as a structured array in the usual 
+`.npy` binary format.
 ```python
 ld.save("ld_file.npy")
 ldarray.load("ld_file.npy")
@@ -156,7 +166,7 @@ ldarray.load("ld_file.npy")
 
 ## Examples
 
-[Transfering structures over an interface](./examples/structures.ipynb)  
+[Struct example](./examples/structures.ipynb)  
 
 
 ## License

{np_struct-0.0.2 → np_struct-0.0.4}/np_struct/__init__.py

@@ -2,4 +2,4 @@
 from . structures import Struct
 from . ldarray import ldarray, Coords
 from . transfer import Packet
-from . import fields
+from . import bitfields

np_struct-0.0.2/np_struct/fields.py → np_struct-0.0.4/np_struct/bitfields.py

@@ -1,9 +1,8 @@
 
 import numpy as np
-from copy import deepcopy as dcopy
 
 
-class npfield(np.ndarray):
+class bitfield(np.ndarray):
 
     def __new__(cls, input_=None, bits=None, doc=None, dtype=None, enum=None):
         
@@ -32,32 +31,31 @@ class npfield(np.ndarray):
         self.doc = getattr(obj, 'doc', "")
         self.enum = getattr(obj, 'enum', None)
         
-    def __array_wrap__(self, out_arr, context=None):
+    def __array_wrap__(self, out_arr, context=None, return_scalar=False):
         
         dtype = np.dtype(self.__class__.__name__.lower())
-        
         return out_arr.astype(dtype)
 
-class uint8(npfield):
+class uint8(bitfield):
     pass
 
-class int8(npfield):
+class int8(bitfield):
     pass
 
-class uint16(npfield):
+class uint16(bitfield):
     pass
 
-class int16(npfield):
+class int16(bitfield):
     pass
 
-class uint32(npfield):
+class uint32(bitfield):
     pass
 
-class int32(npfield):
+class int32(bitfield):
     pass
 
-class float64(npfield):
+class float64(bitfield):
     pass
 
-class float32(npfield):
+class float32(bitfield):
     pass

{np_struct-0.0.2 → np_struct-0.0.4}/np_struct/ldarray.py

@@ -32,6 +32,8 @@ def datetime_idx_handler(v, coords: np.ndarray):
     # if str, treat as UTC formatted string, use same format as is printed with the ldarray __str__ method.
     elif isinstance(v, str):
         v_ts = datetime.datetime.strptime(v, '%Y-%m-%dT%H:%M').timestamp()
+    else:
+        raise NotImplementedError(f"Unsupported datetime index: {type(v)}")
 
     # get index of the minimum distance to the indexing timestamp
     return np.argmin(np.abs(coords_ts - v_ts))
@@ -132,35 +134,39 @@ class Coords(OrderedDict):
     def __setitem__(self, k, v):
         # adds new values to the dictionary
     
-        # cast as numpy array
-        v = np.atleast_1d(v)
-
-        # cast dates (only day/month/year) to more general datetime objects
-        if isinstance(v[0], datetime.date):
-            v = np.array([dt.datetime(year=d.year, month=d.month, day=d.day) for d in v])
+        # cast as list
+        v = [v] if isinstance(v, (str, int, float)) else v
+        v_1d = np.atleast_1d(v)
 
         f64 = np.dtype(np.float64)
         f32 = np.dtype(np.float32)
 
         # Provide default values for index precision if the values are floats
-        if (k not in self.idx_precision.keys()) and (v.dtype in [f64, f32]):
-            if len(v) == 1:
-                self.idx_precision[k] = 1e-10
-            else:
-                self.idx_precision[k] = np.average(np.diff(v))
-        
-        elif isinstance(v[0], datetime.datetime):
+        if v_1d.dtype in [f64, f32]:
+            # add entry to the index precision for this dimension if it doesn't exist 
+            if k not in self.idx_precision.keys():
+                if len(v_1d) == 1:
+                    self.idx_precision[k] = 1e-10
+                else:
+                    self.idx_precision[k] = np.average(np.diff(v_1d))
+
+            super().__setitem__(k, v_1d)
+
+        elif isinstance(v_1d[0], (datetime.datetime, datetime.date)):
+            # cast dates (only day/month/year) to more general datetime objects
+            if isinstance(v_1d[0], datetime.date):
+                v_1d = np.array([dt.datetime(year=d.year, month=d.month, day=d.day) for d in v])
+
             # use index handler for datetime objects
             self.idx_handlers[k] = datetime_idx_handler
-            
-        # add to lookup table otherwise
+            super().__setitem__(k, v_1d)
+
         else:
+            # add to lookup table
             self.idx_label_lut[k] = {vv:i for i,vv in enumerate(v)}
+            super().__setitem__(k, v)
 
-        # call ordered dictionary __setitem__
-        super().__setitem__(k, v)
 
-    
     def get_axis_idx(self, key):
         """ 
         Returns the axis (dimension) index that 'key' has in the lddarray that uses this lddim.
@@ -337,22 +343,30 @@ class ldarray(np.ndarray):
         return results
     
 
-    def sel(self, **keys):
-        return self[keys]
+    def __copy__(self):
+        obj = super().__copy__()
+        obj.coords = dcopy(self.coords)
+        return obj
 
 
-    def __getitem__(self, key):
-        try:
-            return self.getitem(key)
-        except Exception:
-            return super().__getitem__(key)
+    def __deepcopy__(self, memo):
+        return self.__copy__()
 
 
-    def getitem(self, key):
+    def sel(self, **keys):
+        return self[keys]
+    
+
+    def __getitem__(self, key):
         # called whenever array is indexed
         
         # if coords were dropped, use the normal ndarray __getitem__, dictionary coordinates will raise an error here
         if self.coords is None:
+
+            # raise an error if key is a dictionary
+            if isinstance(key, dict):
+                raise IndexError(f"Unable to use dictionary {key} to index an array without coords.")
+            
             return super().__getitem__(key)
 
         # if index is a dictionary, use the dimension labels to index
@@ -368,8 +382,7 @@ class ldarray(np.ndarray):
             return obj
 
         # index is a standard index of slices or integers so pass key to the numpy indexing routine.
-        # this object will have the same coords (not copied) as the object it was indexed from since numpy uses 
-        # the __array_finalize__ method declared above to construct the new array.
+        # this object will have the coords set to None by __array_finalize___
         obj = super(ldarray, self).__getitem__(key)
         
         # shape length can be greater after indexing if np.newaxis was used. In this case just
@@ -387,47 +400,52 @@ class ldarray(np.ndarray):
 
         # At this point, we need to index the dimension dictionary so it matches the obj data,
         # and remove axis that were indexed out completely.
+        try:
+            # Cast index key as a tuple if it's a single value
+            nkey = tuple(key) if isinstance(key, (tuple, list)) else (key,)
 
-        # Cast index key as a tuple if it's a single value
-        nkey = tuple(key) if isinstance(key, (tuple, list)) else (key,)
-
-        # Initialize list of indices for each dimension that will be used to index the label arrays in dim. 
-        # Length is the original array shape length so it matches ndim.
-        idx = [slice(None,None) for i in range(len(self.shape))]
-        
-        # step through index keys and update idx with the appropriate keys.
-        # Keys are always in order of the array dimensions, but axis can be skipped with the Ellipsis operator.
-        idx_i = 0 
-        for ii, k in enumerate(nkey):
-            # jump the current index (idx_i) ahead if there is an Ellipsis.
-            if isinstance(k, type(Ellipsis)):
-                # key after an Ellipsis indexes the dimension starting from the end of the key list
-                idx_i = len(idx) - (len(nkey) - idx_i) 
+            # Initialize list of indices for each dimension that will be used to index the label arrays in dim. 
+            # Length is the original array shape length so it matches ndim.
+            idx = [slice(None,None) for i in range(len(self.shape))]
+            
+            # step through index keys and update idx with the appropriate keys.
+            # Keys are always in order of the array dimensions, but axis can be skipped with the Ellipsis operator.
+            idx_i = 0 
+            for ii, k in enumerate(nkey):
+                # jump the current index (idx_i) ahead if there is an Ellipsis.
+                if isinstance(k, type(Ellipsis)):
+                    # key after an Ellipsis indexes the dimension starting from the end of the key list
+                    idx_i = len(idx) - (len(nkey) - idx_i) 
 
-            else:
-                # update idx with the key, if no key is given for a axis it defaults to ':'
-                idx[idx_i] = k
+                else:
+                    # update idx with the key, if no key is given for a axis it defaults to ':'
+                    idx[idx_i] = k
 
-            idx_i += 1
+                idx_i += 1
 
-        # use idx to index each array of dimension labels in ndim
-        for i, (k,v) in enumerate(self.coords.items()):
-            # numpy removes the dimension if indexed with a integer, so remove it from the dimension label dictionary.
-            if isinstance(idx[i], int):
-                ncoords.pop(k)
+            # use idx to index each array of dimension labels in ndim
+            for i, (k,v) in enumerate(self.coords.items()):
+                # numpy removes the dimension if indexed with a integer, so remove it from the dimension label dictionary.
+                if isinstance(idx[i], int):
+                    ncoords.pop(k)
 
-            else:
-                # reduce the label array for the current axis to match the indexed numpy array.
-                # idx has a value for every dimension so we can use i to get the correct index key
-                ncoords[k] = v[idx[i]]
+                else:
+                    # reduce the label array for the current axis to match the indexed numpy array.
+                    # idx has a value for every dimension so we can use i to get the correct index key
+                    ncoords[k] = np.array(v)[idx[i]]
 
-        # revert to standard numpy array if we weren't able to keep coords consistent with the numpy array data
-        if not check_shapes(obj.shape, ncoords.shape):
-            return obj.view(np.ndarray)
+            # revert to standard numpy array if we weren't able to keep coords consistent with the numpy array data
+            if not check_shapes(obj.shape, ncoords.shape):
+                return obj.view(np.ndarray)
 
-        # if dim and the obj shape match, update the dim member of the indexed obj and return
-        obj.coords = ncoords
-        return obj
+            # if dim and the obj shape match, update the dim member of the indexed obj and return
+            obj.coords = ncoords
+            return obj
+        
+        # if the coords were unable to be indexed, clear the coords and return a unlabeled numpy array.
+        except Exception:
+            obj.coords = None
+            return obj
 
 
     def __setitem__(self, key, value):
@@ -462,7 +480,8 @@ class ldarray(np.ndarray):
 
 
     def __str__(self):
-
+        
+        LEN_THRESHOLD = 7
         s = super().__repr__()
 
         if self.coords is None:
@@ -474,8 +493,19 @@ class ldarray(np.ndarray):
 
             if isinstance(v[0], datetime.datetime):
                 v = np.array(v).astype('datetime64[m]')
+            if isinstance(v, np.ndarray):
+                v_str = np.array2string(v, threshold=LEN_THRESHOLD, suppress_small=True, edgeitems=2, prefix="  ")
+            else:
+                # abbreviate long coordinate lists
+                if len(v) > LEN_THRESHOLD:
+                    v_start = v[:int(LEN_THRESHOLD / 2)]
+                    v_end = v[-int(LEN_THRESHOLD / 2):]
+                    v_str = str(v_start)[:-1] + ", ... " + str(v_end)[1:]
+                else:
+                    v_str = str(v)
+
 
-            s+='\n  '+k + ': '+ np.array2string(v, threshold=3, suppress_small=True, edgeitems=2, prefix="  ")
+            s+='\n  '+k + ': '+ v_str
         
         return s + '\n'
 
@@ -506,10 +536,17 @@ class ldarray(np.ndarray):
             coords_k = self.coords[k]
 
             is_idx_slice = isinstance(v, slice)
+            is_idx_list = isinstance(v, (list, tuple, np.ndarray))
+
+            # allow single value coordinates as lists or tuples
+            if is_idx_list and len(v) > 1:
+                raise IndexError("Only single item lists are supported as indices.")
 
             # cast v as a slice if not already, this allows us to use v.start and v.stop below. Both v.start and 
             # v.stop will be the same when a single value is cast to a slice.
-            if not is_idx_slice:
+            if is_idx_list:
+                v = slice(v[0], v[0], None)
+            elif not is_idx_slice:
                 v = slice(v, v, None)
             
             # check if this dimension has a custom handler defined
@@ -518,10 +555,10 @@ class ldarray(np.ndarray):
                 handler = self.coords.idx_handlers[k]
 
                 # call handler for each start, stop and step value
-                slc_list = [handler(vv, coords_k) if vv is not None else None for vv in [v.start, v.stop, v.step]]
+                slc_list = [handler(vv, coords_k) if vv is not None else None for vv in [v.start, v.stop]]
 
                 # populate numpy index with slice of standard indices
-                np_index[np_i] = slice(slc_list[0], slc_list[1] + 1, slc_list[2])
+                np_index[np_i] = slice(slc_list[0], slc_list[1] + 1, v.step)
 
             # The dimensional key will be in the idx_precision dictionary if the labels are floats.
             # Use approximate indexing based on index precision given in the lddim class.
@@ -576,7 +613,7 @@ class ldarray(np.ndarray):
                 np_index[np_i] = slice(s_start, s_stop, s_step)
 
             # if indexed with single values, convert the index from a slice to a integer
-            if not is_idx_slice:
+            if not is_idx_slice and not is_idx_list:
                 np_index[np_i] = int(np_index[np_i].start)
 
         return tuple(np_index)
@@ -596,7 +633,8 @@ class ldarray(np.ndarray):
 
         # build dtype and value from dimension labels
         # dtype for a structured array is a tuple in the format (name, dtype, shape)
-        for k,v in self.coords.items():
+        for k, v in self.coords.items():
+            v = np.atleast_1d(v)
             dim_value.append(v)
             dim_dtype.append((k, v.dtype, v.shape))
 

{np_struct-0.0.2 → np_struct-0.0.4}/np_struct/structures.py

@@ -1,13 +1,7 @@
-import copy
 import numpy as np
-from . fields import npfield
-from copy import deepcopy as dcopy
+from . bitfields import bitfield
 from collections import OrderedDict as od
 
-_PROTECTED_FIELD_NAMES = ["value", "dtype", "shape", "unpack", "byte_order", "get_size"]
-
-_BYTE_ORDER_TOKENS = ("=", "<", ">", "|")
-
 _SUPPORTED_NP_TYPES = (np.uint8, np.uint16, np.uint32, np.int16, np.int32, np.int64, np.float32, np.float64, np.complex128)
 
 class StructMeta(type):
@@ -30,7 +24,7 @@ class StructMeta(type):
         for key, item in classdict.items():
 
             ## ignore any class definitions that aren't supported numpy types
-            if not isinstance(item, (np.ndarray, Struct, npfield) + _SUPPORTED_NP_TYPES):
+            if not isinstance(item, (np.ndarray, Struct, bitfield) + _SUPPORTED_NP_TYPES):
                 continue
 
             ## error if any private variables are used in class definition, or if there is a naming collision
@@ -164,7 +158,6 @@ class Struct(np.ndarray, metaclass=StructMeta):
         else:
             return ret
 
-
     def unpack(self, bytes):
         """ 
         Unpacks byte data into the structured array for this object. 
@@ -212,7 +205,7 @@ class Struct(np.ndarray, metaclass=StructMeta):
             if len(idx) > 1:
                 build += tabs + '[\n'
             for k, v in self._cls_defs.items():
-                item = getattr(self[*tuple(item_i)], k)
+                item = getattr(self[tuple(item_i)], k)
 
                 key_tab = ' '*(self._printwidth-len(str(k))-1)