np-struct 0.0.1__tar.gz

np-struct-0.0.1/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2023 Rick Lyon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

np-struct-0.0.1/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.1
+Name: np-struct
+Version: 0.0.1
+Summary: user friendly interface for NumPy structured arrays
+Author-email: Rick Lyon <rlyon14@gmail.com>
+Project-URL: repository, https://github.com/ricklyon/np_struct
+Keywords: numpy,structured array,struct
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+License-File: LICENSE.txt
+
+# 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. 
+ 
+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.
+
+## Installation
+
+```bash
+pip install np-struct
+```
+
+## Usage
+
+```python
+import np_struct 
+```
+
+Create a c-style structure with Numpy types.
+
+```python
+from np_struct import Struct
+import numpy as np
+
+class example(Struct):
+    data1 = np.uint32()
+    data2 = np.complex128([0]*3)
+```
+
+Structures can be initialized with arbitrary shapes by using the `shape` kwarg:
+```python
+ex = example(shape = (3,), byte_order='>')
+ex[0].data2 = 1 + 2j
+```
+```bash
+>>> 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. 
+```bash
+>> 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]
+	       [0.+0.j 0.+0.j]]
+```
+
+The structure inherits from np.ndarray and supports all math functions that a normal structured array does.
+To cast as a standard numpy array:
+
+```bash
+>> 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))])
+```
+
+Nested structures are also supported:
+```python
+class nested(Struct):
+    field1 = example()
+    field2 = example()
+
+n = nested()
+n.field1.data2 += j*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]
+```
+
+
+Examples:
+
+[Transfering structures over an interface](./examples/structures.ipynb)  
+[Labeled arrays](./examples/ldarray.ipynb)
+
+
+## License
+
+np-struct is licensed under the MIT License.

np-struct-0.0.1/README.md

@@ -0,0 +1,102 @@
+# 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. 
+ 
+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.
+
+## Installation
+
+```bash
+pip install np-struct
+```
+
+## Usage
+
+```python
+import np_struct 
+```
+
+Create a c-style structure with Numpy types.
+
+```python
+from np_struct import Struct
+import numpy as np
+
+class example(Struct):
+    data1 = np.uint32()
+    data2 = np.complex128([0]*3)
+```
+
+Structures can be initialized with arbitrary shapes by using the `shape` kwarg:
+```python
+ex = example(shape = (3,), byte_order='>')
+ex[0].data2 = 1 + 2j
+```
+```bash
+>>> 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. 
+```bash
+>> 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]
+	       [0.+0.j 0.+0.j]]
+```
+
+The structure inherits from np.ndarray and supports all math functions that a normal structured array does.
+To cast as a standard numpy array:
+
+```bash
+>> 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))])
+```
+
+Nested structures are also supported:
+```python
+class nested(Struct):
+    field1 = example()
+    field2 = example()
+
+n = nested()
+n.field1.data2 += j*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]
+```
+
+
+Examples:
+
+[Transfering structures over an interface](./examples/structures.ipynb)  
+[Labeled arrays](./examples/ldarray.ipynb)
+
+
+## License
+
+np-struct is licensed under the MIT License.

np-struct-0.0.1/np_struct/__init__.py

@@ -0,0 +1,5 @@
+
+from . structures import Struct
+from . ldarray import ldarray, lddim
+from . transfer import Packet
+from . import fields

np-struct-0.0.1/np_struct/fields.py

@@ -0,0 +1,63 @@
+
+import numpy as np
+from copy import deepcopy as dcopy
+
+
+class npfield(np.ndarray):
+
+    def __new__(cls, input_=None, bits=None, doc=None, dtype=None, enum=None):
+        
+        input_ = 0 if np.all(input_ == None) else input_
+
+        ## cast single values as arrays
+        input_ = [input_] if not isinstance(input_, (tuple, list, np.ndarray)) else input_
+        
+        ## set dtype based on class name
+        dtype = np.dtype(cls.__name__.lower())
+        
+        obj = np.asarray(input_, dtype=dtype).view(cls)
+        
+        ## assign member variables
+        obj.bits = bits
+        obj.doc = doc
+        obj.enum = enum
+
+        return obj
+
+    def __array_finalize__(self, obj):
+        ## required method of subclasses of numpy. Sets unique member variables of new instances
+        if obj is None: return
+
+        self.bits = getattr(obj, 'bits', None)
+        self.doc = getattr(obj, 'doc', "")
+        self.enum = getattr(obj, 'enum', None)
+        
+    def __array_wrap__(self, out_arr, context=None):
+        
+        dtype = np.dtype(self.__class__.__name__.lower())
+        
+        return out_arr.astype(dtype)
+
+class uint8(npfield):
+    pass
+
+class int8(npfield):
+    pass
+
+class uint16(npfield):
+    pass
+
+class int16(npfield):
+    pass
+
+class uint32(npfield):
+    pass
+
+class int32(npfield):
+    pass
+
+class float64(npfield):
+    pass
+
+class float32(npfield):
+    pass