Pycubool wrapper [v.01]

- add new functions
- add new classes
- add error code
- add ctypes wrapper
- add wrapper of ctypes wrapper
- add "Add" operation
- add load CuBool library from environment variable

Author: Krekep

python/pycubool/CuBoolWrapper/__init__.py

@@ -0,0 +1,88 @@
+import atexit
+import os
+from ctypes import *
+from .ctypesWrapper import *
+from .codes import check
+
+_lib_wrapper = None
+
+
+class InternalWrapper:
+
+    def __init__(self):
+        self._load_path = os.environ["CUBOOL_PATH"]
+        self._lib = cdll.LoadLibrary(self._load_path)
+        self._instance_new()
+
+        self._declarations = FuncDeclaration(self._lib)
+
+    def unload(self):
+        self._instance_free()
+        del self._lib
+        handle = self._lib._handle
+        self._lib.dlclose(handle)
+
+    def _instance_new(self):
+        self._lib.CuBool_Instance_New.restype = c_int
+        self._lib.CuBool_Instance_New.argtypes = [POINTER(CuBoolInstanceDesc),
+                                                  POINTER(CuBoolInstance)]
+        self._instance = CuBoolInstance()
+        self._descInstance = CuBoolInstanceDesc()
+        status = self._lib.CuBool_Instance_New(pointer(self._instance),
+                                               pointer(self._descInstance))
+        check(status.value)
+        # if status != c_int(0):
+        #     raise Exception("Error at create instance. Code - " + str(status))
+        # print("Status of creating instance is", status)
+
+    def _instance_free(self):
+        self._lib.CuBool_Instance_Free.restype = c_int
+        self._lib.CuBool_Instance_Free.argtypes = [POINTER(CuBoolInstanceDesc),
+                                                   POINTER(CuBoolInstance)]
+        status = self._lib.CuBool_Instance_Free(self._instance)
+        check(status.value)
+
+    def matrix_new(self, nrows, ncols):
+        matrix = CuBoolMatrix()
+        status = self._declarations.matrix_creator(self._instance,
+                                                   pointer(matrix),
+                                                   c_int(nrows),
+                                                   c_int(ncols))
+        return status.value, matrix
+
+    def matrix_free(self, matrix):
+        status = self._declarations.matrix_destructor(self._instance,
+                                                      matrix)
+        return status.value
+
+    def matrix_resize(self, matrix, nrows, ncols):
+        status = self._declarations.matrix_resizer(self._instance,
+                                                   matrix,
+                                                   c_int(nrows),
+                                                   c_int(ncols))
+        return status.value
+
+    def matrix_build(self, matrix, rows, cols, nvals):
+        t_rows = (c_int * len(rows))(*rows)
+        t_cols = (c_int * len(cols))(*cols)
+
+        status = self._declarations.matrix_builder(self._instance,
+                                                   matrix,
+                                                   pointer(t_rows),
+                                                   pointer(t_cols),
+                                                   c_int(nvals))
+        return status.value
+
+    def matrix_add(self, acc_matrix, add_matrix):
+        status = self._declarations.matrix_builder(self._instance,
+                                                   acc_matrix,
+                                                   add_matrix)
+        return status.value, acc_matrix
+
+
+_lib_wrapper = InternalWrapper()
+
+
+def action_at_exit():
+    global _lib_wrapper
+    _lib_wrapper.unload()

python/pycubool/CuBoolWrapper/add.py

@@ -0,0 +1,7 @@
+from CuBoolWrapper import _lib_wrapper, check
+
+
+def Add(accumulate_matrix, add_matrix):
+    temp = _lib_wrapper.matrix_add(accumulate_matrix, add_matrix)
+    check(temp[0])
+    return temp[1]

python/pycubool/CuBoolWrapper/codes.py

@@ -0,0 +1,15 @@
+_return_codes = {
+    0: "CUBOOL_STATUS_SUCCESS",
+    1: "CUBOOL_STATUS_ERROR",
+    2: "CUBOOL_STATUS_DEVICE_NOT_PRESENT",
+    3: "CUBOOL_STATUS_DEVICE_ERROR",
+    4: "CUBOOL_STATUS_MEM_OP_FAILED",
+    5: "CUBOOL_STATUS_INVALID_ARGUMENT",
+    6: "CUBOOL_STATUS_INVALID_STATE",
+    7: "CUBOOL_STATUS_NOT_IMPLEMENTED"
+}
+
+
+def check(res):
+    if res != 0:
+        raise _return_codes[res]

python/pycubool/CuBoolWrapper/ctypesWrapper.py

@@ -0,0 +1,65 @@
+from ctypes import *
+
+
+class CuBoolInstance(Structure):
+    _fields_ = []
+
+
+class CuBoolInstanceDesc(Structure):
+    _fields_ = []
+
+
+class CuBoolMatrix(Structure):
+    _fields_ = []
+
+
+class FuncDeclaration:
+    def __init__(self, lib):
+        self.matrix_creator = FuncDeclaration._matrix_creator(lib)
+        self.matrix_destructor = FuncDeclaration._matrix_destructor(lib)
+        self.matrix_resizer = FuncDeclaration._matrix_resizer(lib)
+        self.matrix_builder = FuncDeclaration._matrix_builder(lib)
+        self.matrix_adder = FuncDeclaration._matrix_adder(lib)
+
+    @staticmethod
+    def _matrix_creator(lib):
+        lib.CuBool_Matrix_New.restype = c_int
+        lib.CuBool_Matrix_New.argtypes = [CuBoolInstance,
+                                          POINTER(CuBoolMatrix),
+                                          c_int,
+                                          c_int]
+        return lib.CuBool_Matrix_New
+
+    @staticmethod
+    def _matrix_destructor(lib):
+        lib.CuBool_Matrix_Free.restype = c_int
+        lib.CuBool_Matrix_Free.argtypes = [CuBoolInstance,
+                                           CuBoolMatrix]
+        return lib.CuBool_Matrix_Free
+
+    @staticmethod
+    def _matrix_resizer(lib):
+        lib.CuBool_Matrix_Resize.restype = c_int
+        lib.CuBool_Matrix_Resize.argtypes = [CuBoolInstance,
+                                             CuBoolMatrix,
+                                             c_int,
+                                             c_int]
+        return lib.CuBool_Matrix_Resize
+
+    @staticmethod
+    def _matrix_builder(lib):
+        lib.CuBool_Matrix_Build.restype = c_int
+        lib.CuBool_Matrix_Build.argtypes = [CuBoolInstance,
+                                            CuBoolMatrix,
+                                            POINTER(c_int),
+                                            POINTER(c_int),
+                                            c_int]
+        return lib.CuBool_Matrix_Build
+
+    @staticmethod
+    def _matrix_adder(lib):
+        lib.CuBool_Matrix_Add.restype = c_int
+        lib.CuBool_Matrix_Add.argtypes = [CuBoolInstance,
+                                          CuBoolMatrix,
+                                          CuBoolMatrix]
+        return lib.CuBool_Matrix_Add

python/pycubool/CuBoolWrapper/matrix.py

@@ -0,0 +1,23 @@
+from CuBoolWrapper import _lib_wrapper
+from codes import check
+
+
+class Matrix:
+    def __init__(self, matrix):
+        self.matrix = matrix
+
+    def __del__(self):
+        check(_lib_wrapper.matrix_free(self, self.matrix))
+
+    @classmethod
+    def sparse(cls, nrows=0, ncols=0):
+        temp = _lib_wrapper.matrix_new(nrows, ncols)
+        check(temp[0])
+        m = cls(temp[1])
+        return m
+
+    def resize(self, nrows, ncols):
+        check(_lib_wrapper.matrix_resize(self.matrix, nrows, ncols))
+
+    def build(self, rows, cols, nvals):
+        check(_lib_wrapper.matrix_build(self.matrix, rows, cols, nvals))

python/pycubool/cubool.py

@@ -1,12 +1,15 @@
-import cubool
-import ctypes
+import CuBoolWrapper
+from CuBoolWrapper.add import Add
+from CuBoolWrapper.matrix import Matrix
 
-print("Enter path to lib")
-path_to_lib = input()
+print("Enter num of rows and cols (a, b)")
+a, b = map(int, input().split())
+matr = Matrix.sparse(a, b)
 
-cubool.CuBoolLibLoad(path_to_lib)
-cubool.CuBool_Instance_New()
+print("Enter num of values, rows and cols ")
+n = int(input())
+rows = list(map(int, input().split()))
+cols = list(map(int, input().split()))
+matr.build(rows, cols, n)
 
-test_matrix = cubool.CuBool_Matrix_New(ctypes.c_int(100), ctypes.c_int(100))
-
-cubool.CuBool_Instance_Free()
+matr = Add(matr, matr)