@@ -0,0 +1,2 @@
+[report]
+show_missing=true

@@ -1,6 +1,3 @@
-# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
-# For more information see: https://docs..com/en/actions/automating-builds-and-tests/building-and-testing-python
-
 name: Python package
 
 on:
@@ -12,34 +9,45 @@ on:
 jobs:
 build:
 
-runs-on: ubuntu-latest
+runs-on: ${{ matrix.os }}
 strategy:
 fail-fast: false
 matrix:
-python-version: ["3.10", "3.11"]
+os: [ubuntu-latest, windows-latest]
+python-version: ["3.10", "3.11", "3.12"]
 
 steps:
 - uses: actions/checkout@v3
+
 - name: Set up Python ${{ matrix.python-version }}
 uses: actions/setup-python@v3
 with:
 python-version: ${{ matrix.python-version }}
+
 - name: Install dependencies
 run: |
 make install
+
  - name: Check code style with black
 run: |
 make code-style
+
  - name: Check import order with isort
 run: |
 make import-check
+
  - name: Lint with flake8
 run: |
 make linting
+
  - name: Check static type checking with mypy
 run: |
 make typecheck
- # FIXME when C backend will be added to CI cache
-# - name: Test with pytest
-# run: |
-# make tests
+
+ - name: Test with pytest
+run: |
+make tests
+
+ - name: Test package build
+run: |
+make build

@@ -21,6 +21,10 @@ install :
 pip-compile requirements.txt -o final_requirements.txt --allow-unsafe --rebuild --verbose
 pip install -e . -r final_requirements.txt
 
+.PHONY : build
+build :
+python -m build
+
 # Testing
 
 .PHONY : code-style
@@ -41,7 +45,10 @@ typecheck :
 
 .PHONY : tests
 tests :
-pytest --color=yes -v -rf
+pytest --color=yes -v -rf --durations=40 \
+--cov-config=.coveragerc \
+--cov=$(SRC) \
+--cov-report=html
 
 # Cleaning
 

@@ -5,10 +5,26 @@
 from dataclasses import dataclass
 from typing import Type, TypeVar
 
+# def is_arch_x86() -> bool:
+# machine = platform.machine()
+# return platform.architecture()[0][0:2] == "32" and (machine[-2:] == "86" or machine[0:3] == "arm")
 
+
+# BUG
 def is_arch_x86() -> bool:
+"""
+Check if the current system architecture is 32-bit and either x86 or ARM.
+
+Returns:
+bool: True if the architecture is 32-bit and x86 or ARM, False otherwise.
+"""
+architecture_bits, _ = platform.architecture()
 machine = platform.machine()
-return platform.architecture()[0][0:2] == "32" and (machine[-2:] == "86" or machine[0:3] == "arm")
+
+is_32_bit = architecture_bits.startswith("32")
+is_x86_or_arm = machine.endswith("86") or machine.startswith("arm")
+
+return is_32_bit and is_x86_or_arm
 
 
 # Define a generic type variable for the base class
@@ -51,6 +67,6 @@ 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]
+def c_array(self) -> ctypes.Array:
 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))

@@ -68,10 +68,6 @@ def __repr__(self) -> str:
 )
 
 
-def is_complex_dtype(dtype: Dtype) -> _python_bool:
-return dtype in {complex32, complex64}
-
-
 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]
 
@@ -88,11 +84,15 @@ def implicit_dtype(number: int | float | _python_bool | complex, array_dtype: Dt
 else:
 raise TypeError(f"{type(number)} is not supported and can not be converted to af.Dtype.")
 
+if array_dtype not in supported_dtypes:
+raise ValueError(f"{array_dtype} is not in supported dtypes.")
+
 if not (array_dtype == float32 or array_dtype == complex32):
 return number_dtype
 
-if number_dtype == float64:
-return float32
+# FIXME
+# if number_dtype == float64:
+# return float32
 
 if number_dtype == complex64:
 return complex64

@@ -1,25 +1,28 @@
 # Testing-related packages
 
 # Checks style, syntax, etc.
-flake8>=4.0.1
+flake8>=6.1.0
 
 # Static type checking
-mypy==1.3.0
+mypy==1.7.1
 
 # Check import order style
-isort>=5.10.1
+isort>=5.13.2
 
 # Automatic code formatting
-black>=23.3.0
+black>=23.12.0
 
 # Allows generation of coverage reports with pytest.
-pytest-cov>=3.0.0
+pytest>=7.4.3
+pytest-cov>=4.1.0
+pytest-mock>=3.11.1
 
 # Allows codecov to generate coverage reports
 coverage[toml]>=6.4
 codecov>=2.1.12
 
-# Package-related packages
+# Package building
 build>=1.0.3
-setuptools
-wheel
+
+# Package publishing
+twine>=4.0.2

@@ -19,5 +19,54 @@ exclude = '''
 '''
 
 [build-system]
-requires = ["setuptools", "wheel", "scikit-build", "cmake", "ninja"]
+requires = [
+"setuptools >= 68.0",
+"wheel >= 0.38.4",
+"scikit-build >= 0.17.6",
+"cmake >= 3.28.1",
+]
 build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = { attr = "arrayfire_wrapper.__version__" }
+
+[project]
+name = "arrayfire-python-wrapper"
+dynamic = ["version"]
+requires-python = ">=3.10"
+authors = [
+{ name = "Anton Chernyatevich", email = "[email protected]" },
+]
+maintainers = [{ name = "ArrayFire", email = "[email protected]" }]
+description = "ArrayFire Python Wrapper"
+readme = "README.md"
+license = { file = "LICENCE" }
+keywords = [
+"arrayfire",
+"c",
+"python",
+"wrapper",
+"parallel computing",
+"gpu",
+"cpu",
+"opencl",
+"oneapi",
+]
+classifiers = [
+"Intended Audience :: Science/Research",
+"Intended Audience :: Developers",
+"Development Status :: 4 - Beta",
+"License :: OSI Approved :: BSD License",
+"Programming Language :: Python",
+"Programming Language :: Python :: 3",
+"Programming Language :: Python :: 3.10",
+"Topic :: Scientific/Engineering",
+"Topic :: Scientific/Engineering :: Artificial Intelligence",
+"Topic :: Scientific/Engineering :: Information Analysis",
+"Topic :: Scientific/Engineering :: Mathematics",
+"Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Website = "http://arrayfire.com"
+"General Documentation" = "https://arrayfire.org/docs/index.htm"

@@ -1,7 +1,78 @@
 import ctypes
+from unittest.mock import 
 
-from arrayfire_wrapper.defines import AFArray
+import pytest
+
+from arrayfire_wrapper.defines import AFArray, ArrayBuffer, CDimT, CShape, _AFBase, is_arch_x86
 
 
 def test_null_pointer_value() -> None:
 assert AFArray.create_null_pointer().value == AFArray(0).value == ctypes.c_void_p(0).value
+
+
+def test_af_base_create_null_pointer() -> None:
+af_base = _AFBase()
+null_pointer = af_base.create_null_pointer()
+assert isinstance(null_pointer, _AFBase)
+
+
+def test_af_array_create_null_pointer() -> None:
+af_array = AFArray()
+null_pointer = af_array.create_null_pointer()
+assert isinstance(null_pointer, AFArray)
+
+
+def test_array_buffer_creation() -> None:
+array_buffer = ArrayBuffer(address=0x1000, length=10)
+
+assert array_buffer.address == 0x1000
+assert array_buffer.length == 10
+
+
+def test_array_buffer_immutable() -> None:
+array_buffer = ArrayBuffer(address=0x2000, length=5)
+
+with pytest.raises(AttributeError):
+array_buffer.address = 0x3000 # type: ignore[misc]
+
+with pytest.raises(AttributeError):
+array_buffer.length = 8 # type: ignore[misc]
+
+
+def test_cshape_creation() -> None:
+c_shape = CShape(1, 2, 3, 4)
+assert c_shape.x1 == 1
+assert c_shape.x2 == 2
+assert c_shape.x3 == 3
+assert c_shape.x4 == 4
+
+
+def test_cshape_repr() -> None:
+c_shape = CShape(1, 2, 3, 4)
+assert repr(c_shape) == "CShape(1, 2, 3, 4)"
+
+
+def test_cshape_c_array() -> None:
+c_shape = CShape(1, 2, 3, 4)
+c_array = c_shape.c_array
+assert isinstance(c_array, ctypes.Array)
+assert len(c_array) == 4
+assert c_array[0] == CDimT(1).value
+assert c_array[1] == CDimT(2).value
+assert c_array[2] == CDimT(3).value
+assert c_array[3] == CDimT(4).value
+
+
+@pytest.mark.parametrize(
+"architecture, machine, expected_result",
+[
+("32bit", "x86", True),
+("32bit", "arm", True),
+("64bit", "x86", False),
+("32bit", "other", False),
+("64bit", "other", False),
+],
+)
+def test_is_arch_x86(architecture: str, machine: str, expected_result: bool) -> None:
+with ("platform.architecture", lambda: (architecture, "")), ("platform.machine", lambda: machine):
+assert is_arch_x86() == expected_result