cunumpy 0.1.2__tar.gz → 0.1.3__tar.gz

{cunumpy-0.1.2 → cunumpy-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.1.2
+Version: 0.1.3
 Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
 Author: Max
 Project-URL: Source, https://github.com/max-models/cunumpy
@@ -52,7 +52,8 @@ export ARRAY_BACKEND=cupy
 
 ```python
 import cunumpy as xp
-arr = xp.array([1,2])
+
+arr = xp.array([1, 2])
 
 print(type(arr))
 print(xp.__version__)

{cunumpy-0.1.2 → cunumpy-0.1.3}/README.md

@@ -16,7 +16,8 @@ export ARRAY_BACKEND=cupy
 
 ```python
 import cunumpy as xp
-arr = xp.array([1,2])
+
+arr = xp.array([1, 2])
 
 print(type(arr))
 print(xp.__version__)

{cunumpy-0.1.2 → cunumpy-0.1.3}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.1.2"
+version = "0.1.3"
 description = "Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`."
 readme = "README.md"
 keywords = [ "python" ]

{cunumpy-0.1.2 → cunumpy-0.1.3}/src/cunumpy/__init__.py

@@ -1,10 +1,14 @@
 # cunumpy/__init__.py
+from importlib.metadata import PackageNotFoundError, version
+
 from . import xp
 from .xp import (
+    cupy_available,
     get_backend,
     is_cpu,
     is_gpu,
     set_backend,
+    set_device,
     synchronize,
     to_cunumpy,
     to_cupy,
@@ -12,19 +16,27 @@ from .xp import (
     use_backend,
 )
 
+try:
+    __version__ = version("cunumpy")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
 __all__ = [
-    "xp",
-    "to_numpy",
-    "to_cupy",
-    "to_cunumpy",
+    "__version__",
+    "cupy_available",
+    "cupy_backend",
     "get_backend",
-    "is_gpu",
     "is_cpu",
-    "use_backend",
+    "is_gpu",
+    "numpy_backend",
     "set_backend",
+    "set_device",
     "synchronize",
-    "numpy_backend",
-    "cupy_backend",
+    "to_cunumpy",
+    "to_cupy",
+    "to_numpy",
+    "use_backend",
+    "xp",
 ]
 
 

{cunumpy-0.1.2 → cunumpy-0.1.3}/src/cunumpy/__init__.pyi

@@ -7,18 +7,21 @@ from typing import Any, Generator
 import numpy as np
 from numpy import *
 
-from . import xp
+from . import xp as xp
 
 def to_numpy(array: Any) -> np.ndarray: ...
 def to_cupy(array: Any) -> Any: ...
 def to_cunumpy(array: Any) -> Any: ...
+def cupy_available() -> bool: ...
 def get_backend(array: Any) -> str: ...
 def is_gpu(array: Any) -> bool: ...
 def is_cpu(array: Any) -> bool: ...
 @contextmanager
-def use_backend(backend: str) -> Generator[None, None, None]: ...
+def use_backend(backend: str) -> Generator[None]: ...
 def set_backend(backend: str) -> None: ...
+def set_device(device_id: int) -> None: ...
 def synchronize() -> None: ...
 
 numpy_backend: bool
 cupy_backend: bool
+__version__: str

{cunumpy-0.1.2 → cunumpy-0.1.3}/src/cunumpy/xp.py

@@ -1,4 +1,5 @@
 import os
+import warnings
 from contextlib import contextmanager
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Generator, Literal
@@ -8,16 +9,42 @@ import numpy as np
 BackendType = Literal["numpy", "cupy"]
 
 
+_CUPY_AVAILABLE_CACHE = None
+
+
+def cupy_available() -> bool:
+    """Check if CuPy is available and functional."""
+    global _CUPY_AVAILABLE_CACHE
+    if _CUPY_AVAILABLE_CACHE is not None:
+        return _CUPY_AVAILABLE_CACHE
+
+    try:
+        import cupy as cp
+
+        # Check if a GPU is available
+        _CUPY_AVAILABLE_CACHE = cp.is_available()
+        return _CUPY_AVAILABLE_CACHE
+    except Exception:  # noqa: BLE001 - tolerate any driver/runtime failure
+        _CUPY_AVAILABLE_CACHE = False
+        return False
+
+
 class ArrayBackend:
+    """Holds the process-wide active backend (NumPy or CuPy).
+
+    Not thread-safe: `set_backend`/`use_backend` mutate this single shared
+    instance in place, so concurrent code (threads, async tasks) switching
+    backends independently will race. Safe for the typical single-threaded
+    script/notebook usage this library targets.
+    """
+
     def __init__(
         self,
         backend: BackendType = "numpy",
         verbose: bool = False,
     ) -> None:
-        assert backend.lower() in [
-            "numpy",
-            "cupy",
-        ], "Array backend must be either 'numpy' or 'cupy'."
+        if backend.lower() not in ("numpy", "cupy"):
+            raise ValueError("Array backend must be either 'numpy' or 'cupy'.")
 
         self._backend: BackendType = "cupy" if backend.lower() == "cupy" else "numpy"
         self._xp: ModuleType = np  # Placeholder
@@ -27,24 +54,25 @@ class ArrayBackend:
 
     def _load_backend(self, backend: BackendType, verbose: bool = False) -> ModuleType:
         if backend == "cupy":
-            try:
+            if cupy_available():
                 import cupy as cp
 
+                self._backend = "cupy"
                 return cp
-            except ImportError:
+            else:
                 if verbose:
-                    print("CuPy not available.")
+                    print(
+                        "CuPy not available or not functional. Falling back to NumPy."
+                    )
+                self._backend = "numpy"
                 return np
         import numpy as np_mod
 
+        self._backend = "numpy"
         return np_mod
 
-    def __init_post__(self, verbose: bool = False) -> None:
-        # This is now redundant but kept for compatibility if called
-        self._xp = self._load_backend(self._backend, verbose)
-        assert isinstance(self._xp, ModuleType)
-        if verbose:
-            print(f"Using {self._xp.__name__} backend.")
+    def __repr__(self) -> str:
+        return f"ArrayBackend(backend={self._backend!r}, module={self._xp.__name__!r})"
 
     @property
     def backend(self) -> BackendType:
@@ -70,15 +98,12 @@ class ArrayBackend:
             self._xp = old_xp
 
 
-# TODO: Make this configurable via environment variable or config file.
 array_backend = ArrayBackend(
     backend=(
         "cupy" if os.getenv("ARRAY_BACKEND", "numpy").lower() == "cupy" else "numpy"
     ),
     verbose=False,
 )
-# Re-run initialization logic properly after backend selection
-array_backend.__init_post__(verbose=False)
 
 
 def use_backend(backend: BackendType) -> Generator[None, None, None]:
@@ -102,6 +127,14 @@ def _numpy_backend() -> bool:
     return array_backend.backend == "numpy"
 
 
+def set_device(device_id: int) -> None:
+    """Select the active CUDA device for the current process (no-op on NumPy)."""
+    if array_backend.backend == "cupy":
+        import cupy as cp
+
+        cp.cuda.Device(device_id).use()
+
+
 def synchronize() -> None:
     """Wait for all kernels in all streams on current device to complete."""
     if array_backend.backend == "cupy":
@@ -109,13 +142,20 @@ def synchronize() -> None:
             import cupy as cp
 
             cp.cuda.Device().synchronize()
-        except (ImportError, AttributeError):
+        except ImportError:
             pass
+        except AttributeError as e:
+            warnings.warn(
+                f"CuPy synchronize() failed unexpectedly, this may indicate a "
+                f"CuPy API mismatch: {e}",
+                RuntimeWarning,
+                stacklevel=2,
+            )
 
 
 def to_numpy(array: Any) -> np.ndarray:
     """Convert an array to a NumPy array."""
-    if hasattr(array, "get"):
+    if get_backend(array) == "cupy":
         return array.get()
 
     return np.asarray(array)
@@ -123,17 +163,17 @@ def to_numpy(array: Any) -> np.ndarray:
 
 def to_cupy(array: Any) -> Any:
     """Convert an array to a CuPy array."""
-    try:
-        import cupy as cp
+    if not cupy_available():
+        raise ImportError("CuPy is not available or not functional.")
 
-        return cp.asarray(array)
-    except ImportError:
-        raise ImportError("CuPy is not available.")
+    import cupy as cp
+
+    return cp.asarray(array)
 
 
 def to_cunumpy(array: Any) -> Any:
     """Convert an array to the currently active backend."""
-    if array_backend.backend == "cupy":
+    if array_backend.backend == "cupy" and cupy_available():
         return to_cupy(array)
     return to_numpy(array)
 
@@ -157,7 +197,7 @@ def is_cpu(array: Any) -> bool:
 # TYPE_CHECKING is True when type checking (e.g., mypy), but False at runtime.
 # This allows us to use autocompletion for xp (i.e., numpy/cupy) as if numpy was imported.
 if TYPE_CHECKING:
-    import numpy as xp
+    import numpy as xp  # noqa: F401 - type-checker-only alias for autocompletion
 else:
     # Use module-level __getattr__ for dynamic xp (Python 3.7+)
     def __getattr__(name):

{cunumpy-0.1.2 → cunumpy-0.1.3}/src/cunumpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.1.2
+Version: 0.1.3
 Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
 Author: Max
 Project-URL: Source, https://github.com/max-models/cunumpy
@@ -52,7 +52,8 @@ export ARRAY_BACKEND=cupy
 
 ```python
 import cunumpy as xp
-arr = xp.array([1,2])
+
+arr = xp.array([1, 2])
 
 print(type(arr))
 print(xp.__version__)