cunumpy 0.1.1__tar.gz → 0.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.1.1
+Version: 0.1.2
 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:
@@ -66,6 +56,28 @@ 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.2/README.md

@@ -0,0 +1,54 @@
+# 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.2}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.1.1"
+version = "0.1.2"
 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.2/src/cunumpy/__init__.py

@@ -0,0 +1,37 @@
+# cunumpy/__init__.py
+from . import xp
+from .xp import (
+    get_backend,
+    is_cpu,
+    is_gpu,
+    set_backend,
+    synchronize,
+    to_cunumpy,
+    to_cupy,
+    to_numpy,
+    use_backend,
+)
+
+__all__ = [
+    "xp",
+    "to_numpy",
+    "to_cupy",
+    "to_cunumpy",
+    "get_backend",
+    "is_gpu",
+    "is_cpu",
+    "use_backend",
+    "set_backend",
+    "synchronize",
+    "numpy_backend",
+    "cupy_backend",
+]
+
+
+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.2/src/cunumpy/__init__.pyi

@@ -0,0 +1,24 @@
+# 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
+
+def to_numpy(array: Any) -> np.ndarray: ...
+def to_cupy(array: Any) -> Any: ...
+def to_cunumpy(array: Any) -> Any: ...
+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 set_backend(backend: str) -> None: ...
+def synchronize() -> None: ...
+
+numpy_backend: bool
+cupy_backend: bool

cunumpy-0.1.2/src/cunumpy/xp.py

@@ -0,0 +1,170 @@
+import os
+from contextlib import contextmanager
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Generator, Literal
+
+import numpy as np
+
+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"
+        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":
+            try:
+                import cupy as cp
+
+                return cp
+            except ImportError:
+                if verbose:
+                    print("CuPy not available.")
+                return np
+        import numpy as np_mod
+
+        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.")
+
+    @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
+
+
+# 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]:
+    """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 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, AttributeError):
+            pass
+
+
+def to_numpy(array: Any) -> np.ndarray:
+    """Convert an array to a NumPy array."""
+    if hasattr(array, "get"):
+        return array.get()
+
+    return np.asarray(array)
+
+
+def to_cupy(array: Any) -> Any:
+    """Convert an array to a CuPy array."""
+    try:
+        import cupy as cp
+
+        return cp.asarray(array)
+    except ImportError:
+        raise ImportError("CuPy is not available.")
+
+
+def to_cunumpy(array: Any) -> Any:
+    """Convert an array to the currently active backend."""
+    if array_backend.backend == "cupy":
+        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
+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.2}/src/cunumpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.1.1
+Version: 0.1.2
 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:
@@ -66,6 +56,28 @@ 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