Add creation functions. Restructure data structures (#2)

* Add creation functions

* Restructure data structures

Author: roaffix

arrayfire_wrapper/__init__.py

@@ -8,7 +8,7 @@
 __arrayfire_version__ = ARRAYFIRE_VERSION
 
 __all__ += ["add"]
-from arrayfire_wrapper.library.mathematical_functions import add
+from arrayfire_wrapper.lib.mathematical_functions import add
 
 __all__ += ["randu"]
-from arrayfire_wrapper.library.create_and_modify_array import randu
+from arrayfire_wrapper.lib.create_and_modify_array import randu

arrayfire_wrapper/_typing.py

@@ -10,14 +10,9 @@
 from pathlib import Path
 from typing import Iterator
 
-from arrayfire_wrapper.version import ARRAYFIRE_VER_MAJOR
-
 from ._logger import logger
-
-
-def is_arch_x86() -> bool:
-    machine = platform.machine()
-    return platform.architecture()[0][0:2] == "32" and (machine[-2:] == "86" or machine[0:3] == "arm")
+from .defines import is_arch_x86
+from .version import ARRAYFIRE_VER_MAJOR
 
 
 class _LibPrefixes(Enum):

arrayfire_wrapper/backend.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import ctypes
+import platform
+from dataclasses import dataclass
+from enum import Enum
+from typing import Type
+
+
+def is_arch_x86() -> bool:
+    machine = platform.machine()
+    return platform.architecture()[0][0:2] == "32" and (machine[-2:] == "86" or machine[0:3] == "arm")
+
+
+# A handle for an internal array object
+class AFArray(ctypes.c_void_p):
+    @classmethod
+    def create_null_pointer(cls) -> AFArray:
+        cls.value = None
+        return cls()
+
+
+CType = Type[ctypes._SimpleCData]
+CDimT = ctypes.c_int if is_arch_x86() else ctypes.c_longlong
+
+
+@dataclass(frozen=True)
+class ArrayBuffer:
+    address: int
+    length: int = 0
+
+
+class CShape(tuple):
+    def __new__(cls, *args: int) -> CShape:
+        cls.original_shape = len(args)
+        return tuple.__new__(cls, args)
+
+    def __init__(self, x1: int = 1, x2: int = 1, x3: int = 1, x4: int = 1) -> None:
+        self.x1 = x1
+        self.x2 = x2
+        self.x3 = x3
+        self.x4 = x4
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}{self.x1, self.x2, self.x3, self.x4}"
+
+    @property
+    def c_array(self):  # type: ignore[no-untyped-def]
+        c_shape = CDimT * 4  # ctypes.c_int | ctypes.c_longlong * 4
+        return c_shape(CDimT(self.x1), CDimT(self.x2), CDimT(self.x3), CDimT(self.x4))
+
+
+class Moment(Enum):
+    M00 = 1
+    M01 = 2
+    M10 = 4
+    M11 = 8
+    FIRST_ORDER = M00 | M01 | M10 | M11

arrayfire_wrapper/defines.py

@@ -2,11 +2,9 @@
 
 import ctypes
 from dataclasses import dataclass
-from typing import Type, TypeAlias
 
-from .backend import is_arch_x86
+from .defines import CType
 
-CType = Type[ctypes._SimpleCData]
 _python_bool = bool
 
 
@@ -63,31 +61,7 @@ def is_complex_dtype(dtype: Dtype) -> _python_bool:
     return dtype in {complex64, complex128}
 
 
-c_dim_t = ctypes.c_int if is_arch_x86() else ctypes.c_longlong
-ShapeType = tuple[int, ...]
-
-
-class CShape(tuple):
-    def __new__(cls, *args: int) -> CShape:
-        cls.original_shape = len(args)
-        return tuple.__new__(cls, args)
-
-    def __init__(self, x1: int = 1, x2: int = 1, x3: int = 1, x4: int = 1) -> None:
-        self.x1 = x1
-        self.x2 = x2
-        self.x3 = x3
-        self.x4 = x4
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}{self.x1, self.x2, self.x3, self.x4}"
-
-    @property
-    def c_array(self):  # type: ignore[no-untyped-def]
-        c_shape = c_dim_t * 4  # ctypes.c_int | ctypes.c_longlong * 4
-        return c_shape(c_dim_t(self.x1), c_dim_t(self.x2), c_dim_t(self.x3), c_dim_t(self.x4))
-
-
-def to_str(c_str: ctypes.c_char_p) -> str:
+def to_str(c_str: ctypes.c_char_p | ctypes.Array[ctypes.c_char]) -> str:
     return str(c_str.value.decode("utf-8"))  # type: ignore[union-attr]
 
 

arrayfire_wrapper/dtypes.py

@@ -0,0 +1,15 @@
+class Bcast:
+    def __init__(self) -> None:
+        self._flag: bool = False
+
+    def get(self) -> bool:
+        return self._flag
+
+    def set(self, flag: bool) -> None:
+        self._flag = flag
+
+    def toggle(self) -> None:
+        self._flag ^= True
+
+
+bcast_var: Bcast = Bcast()

arrayfire_wrapper/library/__init__.py arrayfire_wrapper/lib/__init__.pyarrayfire_wrapper/library/__init__.py renamed to arrayfire_wrapper/lib/__init__.py

@@ -2,7 +2,8 @@
 from enum import Enum
 
 from arrayfire_wrapper.backend import _backend
-from arrayfire_wrapper.dtypes import c_dim_t, to_str
+from arrayfire_wrapper.defines import CDimT
+from arrayfire_wrapper.dtypes import to_str
 
 
 class _ErrorCodes(Enum):
@@ -14,6 +15,6 @@ def safe_call(c_err: int) -> None:
         return
 
     err_str = ctypes.c_char_p(0)
-    err_len = c_dim_t(0)
+    err_len = CDimT(0)
     _backend.clib.af_get_last_error(ctypes.pointer(err_str), ctypes.pointer(err_len))
     raise RuntimeError(to_str(err_str))

arrayfire_wrapper/lib/_broadcast.py

@@ -3,9 +3,9 @@
 import ctypes
 from collections.abc import Callable
 
-from arrayfire_wrapper._typing import AFArray
-from arrayfire_wrapper.library._broadcast import bcast_var
-from arrayfire_wrapper.library._error_handler import safe_call
+from arrayfire_wrapper.defines import AFArray
+from arrayfire_wrapper.lib._broadcast import bcast_var
+from arrayfire_wrapper.lib._error_handler import safe_call
 
 
 def binary_op(c_func: Callable, lhs: AFArray, rhs: AFArray, /) -> AFArray:

…ayfire_wrapper/library/_error_handler.py arrayfire_wrapper/lib/_error_handler.pyarrayfire_wrapper/library/_error_handler.py renamed to arrayfire_wrapper/lib/_error_handler.py arrayfire_wrapper/library/_error_handler.py renamed to arrayfire_wrapper/lib/_error_handler.py

@@ -1,6 +1,6 @@
 # flake8: noqa
 __all__ = [
-    "AFRandomEngine",
+    "AFRandomEngineHandle",
     "create_random_engine",
     "random_engine_get_seed",
     "random_engine_get_type",
@@ -12,7 +12,7 @@
 ]
 
 from .create_array.random_number_generation import (
-    AFRandomEngine,
+    AFRandomEngineHandle,
     create_random_engine,
     random_engine_get_seed,
     random_engine_get_type,