Fix build components (#10)

* Deprecate setup.py build and transit to pyproject.

* Fix some tests

* Fix dependencies

* Add build command to makefile

Author: roaffix

Diff for: .coveragerc

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

Diff for: .github/workflows/python-package.yml

@@ -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.github.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

Diff for: Makefile

@@ -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
 

Diff for: arrayfire_wrapper/defines.py

@@ -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))

Diff for: arrayfire_wrapper/dtypes.py

@@ -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

Diff for: dev-requirements.txt

@@ -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

Diff for: pyproject.toml

@@ -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"

Diff for: setup.py

@@ -1,7 +1,78 @@
 import ctypes
+from unittest.mock import patch
 
-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 patch("platform.architecture", lambda: (architecture, "")), patch("platform.machine", lambda: machine):
+        assert is_arch_x86() == expected_result