cunumpy 0.1.1__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.1.1
+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
@@ -40,18 +40,8 @@ Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cun
 
 # Install
 
-Create and activate python environment
-
-```
-python -m venv env
-source env/bin/activate
-pip install --upgrade pip
-```
-
-Install the code and requirements with pip
-
-```
-pip install -e .
+```bash
+pip install cunumpy
 ```
 
 Example usage:
@@ -62,10 +52,33 @@ 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__)
+
+# Convert to NumPy
+arr_np = xp.to_numpy(arr)
+
+# Convert to active backend
+arr_xp = xp.to_cunumpy(arr)
+
+# Inspect backend
+print(xp.get_backend(arr))
+print(xp.is_gpu(arr))
+print(xp.is_cpu(arr))
+
+# Temporarily switch backend
+with xp.use_backend("numpy"):
+    # This code runs on CPU even if ARRAY_BACKEND=cupy
+    arr_cpu = xp.zeros(100)
+
+# Set backend globally
+xp.set_backend("cupy")
+
+# Synchronize GPU operations (no-op on CPU)
+xp.synchronize()
 ```
 
 # Build docs

cunumpy-0.1.3/README.md

@@ -0,0 +1,55 @@
+# CuNumpy
+
+Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
+
+# Install
+
+```bash
+pip install cunumpy
+```
+
+Example usage:
+
+```
+export ARRAY_BACKEND=cupy
+```
+
+```python
+import cunumpy as xp
+
+arr = xp.array([1, 2])
+
+print(type(arr))
+print(xp.__version__)
+
+# Convert to NumPy
+arr_np = xp.to_numpy(arr)
+
+# Convert to active backend
+arr_xp = xp.to_cunumpy(arr)
+
+# Inspect backend
+print(xp.get_backend(arr))
+print(xp.is_gpu(arr))
+print(xp.is_cpu(arr))
+
+# Temporarily switch backend
+with xp.use_backend("numpy"):
+    # This code runs on CPU even if ARRAY_BACKEND=cupy
+    arr_cpu = xp.zeros(100)
+
+# Set backend globally
+xp.set_backend("cupy")
+
+# Synchronize GPU operations (no-op on CPU)
+xp.synchronize()
+```
+
+# Build docs
+
+
+```
+make html
+cd ../
+open docs/_build/html/index.html
+```

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

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.1.1"
+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" ]
@@ -51,3 +51,6 @@ where = [ "src" ]
 
 [tool.setuptools.package-data]
 cunumpy = [ "py.typed", "*.pyi" ]
+
+[tool.isort]
+profile = "black"

cunumpy-0.1.3/src/cunumpy/__init__.py

@@ -0,0 +1,49 @@
+# 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,
+    to_numpy,
+    use_backend,
+)
+
+try:
+    __version__ = version("cunumpy")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "__version__",
+    "cupy_available",
+    "cupy_backend",
+    "get_backend",
+    "is_cpu",
+    "is_gpu",
+    "numpy_backend",
+    "set_backend",
+    "set_device",
+    "synchronize",
+    "to_cunumpy",
+    "to_cupy",
+    "to_numpy",
+    "use_backend",
+    "xp",
+]
+
+
+def __getattr__(name: str):
+    """Set cunumpy.<name> to cunumpy.xp.<name> (NumPy/CuPy)."""
+    if name == "numpy_backend":
+        return xp.numpy_backend
+    if name == "cupy_backend":
+        return xp.cupy_backend
+    return getattr(xp.xp, name)

cunumpy-0.1.3/src/cunumpy/__init__.pyi

@@ -0,0 +1,27 @@
+# Stub file for Pylance/mypy: exposes all numpy symbols so that
+# `import cunumpy as xp` followed by `xp.<Tab>` shows numpy completions.
+# At runtime the real __init__.py dispatches to numpy or cupy via __getattr__.
+from contextlib import contextmanager
+from typing import Any, Generator
+
+import numpy as np
+from numpy import *
+
+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]: ...
+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.3/src/cunumpy/xp.py

@@ -0,0 +1,210 @@
+import os
+import warnings
+from contextlib import contextmanager
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Generator, Literal
+
+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:
+        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
+
+        # Import numpy/cupy
+        self._xp = self._load_backend(self._backend, verbose)
+
+    def _load_backend(self, backend: BackendType, verbose: bool = False) -> ModuleType:
+        if backend == "cupy":
+            if cupy_available():
+                import cupy as cp
+
+                self._backend = "cupy"
+                return cp
+            else:
+                if verbose:
+                    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 __repr__(self) -> str:
+        return f"ArrayBackend(backend={self._backend!r}, module={self._xp.__name__!r})"
+
+    @property
+    def backend(self) -> BackendType:
+        return self._backend
+
+    @property
+    def xp(self) -> ModuleType:
+        return self._xp
+
+    @contextmanager
+    def use_backend(self, backend: BackendType) -> Generator[None, None, None]:
+        """Temporarily change the backend."""
+        old_backend = self._backend
+        old_xp = self._xp
+
+        self._backend = backend
+        self._xp = self._load_backend(backend)
+
+        try:
+            yield
+        finally:
+            self._backend = old_backend
+            self._xp = old_xp
+
+
+array_backend = ArrayBackend(
+    backend=(
+        "cupy" if os.getenv("ARRAY_BACKEND", "numpy").lower() == "cupy" else "numpy"
+    ),
+    verbose=False,
+)
+
+
+def use_backend(backend: BackendType) -> Generator[None, None, None]:
+    """Temporarily change the backend."""
+    return array_backend.use_backend(backend)
+
+
+def set_backend(backend: BackendType) -> None:
+    """Set the backend globally."""
+    array_backend._backend = backend
+    array_backend._xp = array_backend._load_backend(backend)
+
+
+def _cupy_backend() -> bool:
+    """Check if the active global backend is CuPy."""
+    return array_backend.backend == "cupy"
+
+
+def _numpy_backend() -> bool:
+    """Check if the active global backend is NumPy."""
+    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":
+        try:
+            import cupy as cp
+
+            cp.cuda.Device().synchronize()
+        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 get_backend(array) == "cupy":
+        return array.get()
+
+    return np.asarray(array)
+
+
+def to_cupy(array: Any) -> Any:
+    """Convert an array to a CuPy array."""
+    if not cupy_available():
+        raise ImportError("CuPy is not available or not functional.")
+
+    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" and cupy_available():
+        return to_cupy(array)
+    return to_numpy(array)
+
+
+def get_backend(array: Any) -> BackendType:
+    """Return 'cupy' or 'numpy' depending on the array type."""
+    module = getattr(type(array), "__module__", "")
+    return "cupy" if "cupy" in module else "numpy"
+
+
+def is_gpu(array: Any) -> bool:
+    """Check if the array is stored on a GPU (CuPy)."""
+    return get_backend(array) == "cupy"
+
+
+def is_cpu(array: Any) -> bool:
+    """Check if the array is stored on a CPU (NumPy)."""
+    return get_backend(array) == "numpy"
+
+
+# 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  # noqa: F401 - type-checker-only alias for autocompletion
+else:
+    # Use module-level __getattr__ for dynamic xp (Python 3.7+)
+    def __getattr__(name):
+        if name == "xp":
+            return array_backend.xp
+        if name == "numpy_backend":
+            return _numpy_backend()
+        if name == "cupy_backend":
+            return _cupy_backend()
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.1.1
+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
@@ -40,18 +40,8 @@ Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cun
 
 # Install
 
-Create and activate python environment
-
-```
-python -m venv env
-source env/bin/activate
-pip install --upgrade pip
-```
-
-Install the code and requirements with pip
-
-```
-pip install -e .
+```bash
+pip install cunumpy
 ```
 
 Example usage:
@@ -62,10 +52,33 @@ 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__)
+
+# Convert to NumPy
+arr_np = xp.to_numpy(arr)
+
+# Convert to active backend
+arr_xp = xp.to_cunumpy(arr)
+
+# Inspect backend
+print(xp.get_backend(arr))
+print(xp.is_gpu(arr))
+print(xp.is_cpu(arr))
+
+# Temporarily switch backend
+with xp.use_backend("numpy"):
+    # This code runs on CPU even if ARRAY_BACKEND=cupy
+    arr_cpu = xp.zeros(100)
+
+# Set backend globally
+xp.set_backend("cupy")
+
+# Synchronize GPU operations (no-op on CPU)
+xp.synchronize()
 ```
 
 # Build docs

cunumpy-0.1.1/README.md

@@ -1,42 +0,0 @@
-# CuNumpy
-
-Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
-
-# Install
-
-Create and activate python environment
-
-```
-python -m venv env
-source env/bin/activate
-pip install --upgrade pip
-```
-
-Install the code and requirements with pip
-
-```
-pip install -e .
-```
-
-Example usage:
-
-```
-export ARRAY_BACKEND=cupy
-```
-
-```python
-import cunumpy as xp
-arr = xp.array([1,2])
-
-print(type(arr))
-print(xp.__version__)
-```
-
-# Build docs
-
-
-```
-make html
-cd ../
-open docs/_build/html/index.html
-```

cunumpy-0.1.1/src/cunumpy/__init__.py

@@ -1,9 +0,0 @@
-# cunumpy/__init__.py
-from . import xp
-
-__all__ = ["xp"]
-
-
-def __getattr__(name: str):
-    """Set cunumpy.<name> to cunumpy.xp.<name> (NumPy/CuPy)."""
-    return getattr(xp.xp, name)

cunumpy-0.1.1/src/cunumpy/__init__.pyi

@@ -1,7 +0,0 @@
-# Stub file for Pylance/mypy: exposes all numpy symbols so that
-# `import cunumpy as xp` followed by `xp.<Tab>` shows numpy completions.
-# At runtime the real __init__.py dispatches to numpy or cupy via __getattr__.
-from numpy import *
-from numpy import __config__, __version__
-
-from . import xp

cunumpy-0.1.1/src/cunumpy/xp.py

@@ -1,64 +0,0 @@
-import os
-from types import ModuleType
-from typing import TYPE_CHECKING, Literal
-
-BackendType = Literal["numpy", "cupy"]
-
-
-class ArrayBackend:
-    def __init__(
-        self,
-        backend: BackendType = "numpy",
-        verbose: bool = False,
-    ) -> None:
-        assert backend.lower() in [
-            "numpy",
-            "cupy",
-        ], "Array backend must be either 'numpy' or 'cupy'."
-
-        self._backend: BackendType = "cupy" if backend.lower() == "cupy" else "numpy"
-
-        # Import numpy/cupy
-        if self.backend == "cupy":
-            try:
-                import cupy as cp
-
-                self._xp = cp
-            except ImportError:
-                if verbose:
-                    print("CuPy not available.")
-                self._backend = "numpy"
-
-        if self.backend == "numpy":
-            import numpy as np
-
-            self._xp = np
-
-        assert isinstance(self.xp, ModuleType)
-
-        if verbose:
-            print(f"Using {self.xp.__name__} backend.")
-
-    @property
-    def backend(self) -> BackendType:
-        return self._backend
-
-    @property
-    def xp(self) -> ModuleType:
-        return self._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,
-)
-
-# 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
-else:
-    xp = array_backend.xp