squarenet 1.3.2__tar.gz → 1.3.4__tar.gz

{squarenet-1.3.2 → squarenet-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squarenet
-Version: 1.3.2
+Version: 1.3.4
 Summary: Gridification for point clouds in any dimension (fast greedy optimal transport through Cartesian Sort).
 Author-email: ArmanddeCacqueray <armanddecacqueray@sfr.fr>
 Project-URL: Homepage, https://github.com/ArmanddeCacqueray/SquareNet

{squarenet-1.3.2 → squarenet-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "squarenet"
-version = "1.3.2"
+version = "1.3.4"
 description = "Gridification for point clouds in any dimension (fast greedy optimal transport through Cartesian Sort)."
 authors = [{ name = "ArmanddeCacqueray", email = "armanddecacqueray@sfr.fr" }]
 readme = "README.md"

squarenet-1.3.4/src/squarenet/__init__.py

@@ -0,0 +1,4 @@
+from .squarenet import SquareNet 
+
+__all__ = ["SquareNet", "samplepoints", "plotpoints", "sqplot", "carthesian_sort"]
+__version__ = "1.3.4"

{squarenet-1.3.2 → squarenet-1.3.4}/src/squarenet/artist.py

@@ -492,7 +492,16 @@ def sqplot(grid, verbose, style="checkerboard", animate=False,
                         print(f"ffmpeg unavailable. Npoints = {rounded} and style is 'scatter' -> could take 1/2 minutes")   
                     else:
                         print(f"ffmpeg unavailable. Npoints = {rounded} -> could take 20/30 seconds")
-            ani.save(save_path, writer=writer, fps=full_cfg["fps"])
+            if has_ffmpeg:
+                from matplotlib.animation import FFMpegWriter
+                # On passe le fps ICI, lors de la création de l'objet
+                writer = FFMpegWriter(fps=full_cfg["fps"], codec="h264", bitrate=-1)
+                # Et on ne le passe PLUS dans .save()
+                ani.save(save_path, writer=writer)
+            else:
+                writer = "pillow"
+                # Avec le string "pillow", on doit passer le fps dans .save()
+                ani.save(save_path, writer=writer, fps=full_cfg["fps"])
         else:
             if cfg["show"]:
                 plt.show()

squarenet-1.3.4/src/squarenet/backends.py

@@ -0,0 +1,67 @@
+import numpy as np
+
+
+def from_backend(x):
+    """Convert any supported array/tensor to a NumPy ndarray."""
+    if isinstance(x, np.ndarray):
+        return x
+    module = type(x).__module__.split(".")[0]
+    if module == "torch":
+        return x.detach().cpu().numpy()
+    return np.asarray(x)
+
+
+def get_backend_device(x):
+    """Return (backend, device) for a supported array."""
+    if isinstance(x, np.ndarray):
+        return "numpy", "cpu"
+    module = type(x).__module__.split(".")[0]
+    if module == "torch":
+        return "torch", str(x.device)
+    if module in ("jax", "jaxlib"):
+        dev = getattr(x, "device", None)
+        return "jax", str(dev) if dev is not None else "unknown"
+    return "unknown", None
+
+
+def to_backend(x, backend="numpy"):
+    """
+    Convert arrays between NumPy, Torch and JAX.
+
+    Philosophy
+    ----------
+    - If backend already match, return x unchanged.
+    - Otherwise always convert through NumPy.
+    """
+    current_backend, current_device = get_backend_device(x)
+    # ------------------------------------------------------------------
+    # Already on requested backend/device
+    # ------------------------------------------------------------------
+    if backend == current_backend:
+        return x
+    # ------------------------------------------------------------------
+    # Convert through NumPy
+    # ------------------------------------------------------------------
+    arr = from_backend(x)
+    # ------------------------------------------------------------------
+    # NumPy
+    # ------------------------------------------------------------------
+    if backend == "numpy":
+        return arr
+    # ------------------------------------------------------------------
+    # Torch
+    # ------------------------------------------------------------------
+    if backend == "torch":
+        import torch
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        return torch.as_tensor(arr, device=torch.device(device))
+    # ------------------------------------------------------------------
+    # JAX
+    # ------------------------------------------------------------------
+    if backend == "jax":
+        import jax.numpy as jnp
+        out = jnp.asarray(arr)
+        return out
+    raise ValueError(
+        f"Unknown backend '{backend}'. Expected 'numpy', 'torch' or 'jax'."
+    )

{squarenet-1.3.2 → squarenet-1.3.4}/src/squarenet/squarenet.py

@@ -5,7 +5,8 @@ from .core import carthesian_sort
 from .artist import sqplot, default_config
 from .sampler import samplepoints
 from .neighbormap import neighbormap
-from .utils import make_stencil, fill_in, dualgrid, dualgridflat, from_backend, to_backend, printmatrix
+from .utils import make_stencil, fill_in, dualgrid, dualgridflat, printmatrix
+from .backends import from_backend, to_backend
 
 class SquareNet:
     """
@@ -58,7 +59,6 @@ class SquareNet:
         self.max_iter = max_iter
         self.verbose = verbose
         self.backend = backend
-        self.device = "cpu"
         self._torchdevice = "cpu"
 
         if backend not in {"numpy", "jax", "torch"}:
@@ -90,7 +90,7 @@ class SquareNet:
             import torch
             self.xp = torch
             if torch.cuda.is_available():
-                self.device = torch.device("cuda")
+                self._torchdevice = torch.device("cuda")
 
         self.warnings_ = warnings_
         if stencil is not None:
@@ -104,7 +104,7 @@ class SquareNet:
     # Internal utilities
     # ------------------------------------------------------------------
     def _to_backend(self, x):
-        return to_backend(x, backend = self.backend, device = self.device, warnings_ = self.warnings_)
+        return to_backend(x, backend = self.backend, warnings_ = self.warnings_)
     
     def _reset_state(self):
         """Reset internal state to initial configuration."""
@@ -228,16 +228,12 @@ class SquareNet:
         see ``squarenet.core``
         """
         old_backend = self.backend
-        old_device = self.device
-
         if self._torchdevice != "cpu":
-            #just for the fit, will be updated after
+            #We will fit on GPU with torch
             self.backend = "torch"
-            self.device = self._torchdevice
         else: 
-            #just for the fit, will be updated after
+            #We will fit on CPU with numpy
             self.backend = "numpy"
-            self.device = "cpu"
 
         true_g = np.array(self.gridshape)
         true_g = true_g[true_g > 1]
@@ -303,7 +299,6 @@ class SquareNet:
                     )
         
         self.backend = old_backend
-        self.device = old_device
         self.grid = self._to_backend(grid)
         self.points = self._to_backend(points)
         # --------------------------------------------------

{squarenet-1.3.2 → squarenet-1.3.4}/src/squarenet/utils.py

@@ -213,82 +213,6 @@ def project(gridpoints, feature_axes=(0, 1), index=0):
     
     return x
 
-
-def from_backend(x):
-    """
-    Safely convert Torch, JAX, or array-like objects back to Numpy.
-    """
-    # 1. Already a Numpy array
-    if isinstance(x, np.ndarray):
-        return x
-
-    # 2. PyTorch tensor 
-    if hasattr(x, "detach"):
-        return x.detach().cpu().numpy()
-
-    # 3. JAX arrays or any object with __array__ protocol (Pandas, etc.)
-    return np.asarray(x)
-
-def to_backend(x, backend="numpy", device="cpu", warnings_=True):
-    """
-    Convert arrays/tensors between Numpy, Torch, and JAX.
-    Utilizes DLPack for zero-copy transfers across frameworks when possible.
-    """
-    # Identify input framework without heavy imports
-    in_type = type(x).__module__.split('.')[0]
-
-    # ---------------------------------------------------------
-    # 1. Target: NUMPY
-    # ---------------------------------------------------------
-    if backend == "numpy":
-        return from_backend(x)
-
-    # ---------------------------------------------------------
-    # 2. Target: TORCH
-    # ---------------------------------------------------------
-    elif backend == "torch":
-        import torch
-        tgt_dev = torch.device(device)
-        
-        if in_type == "torch":
-            if warnings_ and x.device.type != "cpu" and tgt_dev.type == "cpu":
-                warn("Downgrading tensor: initial device was GPU but asked for CPU.")
-            return x.to(tgt_dev)
-            
-        elif in_type in ["jax", "jaxlib"]:
-            # Zero-copy JAX to Torch via DLPack
-            return torch.from_dlpack(x).to(tgt_dev)
-            
-        return torch.as_tensor(x, device=tgt_dev)
-
-    # ---------------------------------------------------------
-    # 3. Target: JAX
-    # ---------------------------------------------------------
-    elif backend == "jax":
-        import jax
-        import jax.numpy as jnp
-        
-        # JAX uses "gpu" instead of "cuda"
-        device = "cpu" if "cpu" in str(device) else "gpu"
-        try:
-            tgt_dev = jax.devices(device)[0]
-        except RuntimeError:
-            tgt_dev = None
-
-        if in_type == "torch":
-            import torch.utils.dlpack
-            # DLPack requires contiguous memory
-            x = x if x.is_contiguous() else x.contiguous()
-            j_arr = jax.dlpack.from_dlpack(torch.utils.dlpack.to_dlpack(x))
-            return jax.device_put(j_arr, tgt_dev) if tgt_dev else j_arr
-            
-        elif in_type in ["jax", "jaxlib"]:
-            return jax.device_put(x, tgt_dev) if tgt_dev else x
-            
-        return jax.device_put(x, tgt_dev) if tgt_dev else jnp.asarray(x)
-
-    raise ValueError(f"Unknown backend: '{backend}'. Expected 'numpy', 'torch', or 'jax'.")
-
 def progress_bar(it, total, bar_length=30):
     progress = it / total
     filled = int(bar_length * progress)

{squarenet-1.3.2 → squarenet-1.3.4}/src/squarenet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squarenet
-Version: 1.3.2
+Version: 1.3.4
 Summary: Gridification for point clouds in any dimension (fast greedy optimal transport through Cartesian Sort).
 Author-email: ArmanddeCacqueray <armanddecacqueray@sfr.fr>
 Project-URL: Homepage, https://github.com/ArmanddeCacqueray/SquareNet

{squarenet-1.3.2 → squarenet-1.3.4}/src/squarenet.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 src/squarenet/__init__.py
 src/squarenet/artist.py
+src/squarenet/backends.py
 src/squarenet/core.py
 src/squarenet/neighbormap.py
 src/squarenet/sampler.py

squarenet-1.3.2/src/squarenet/__init__.py

@@ -1,4 +0,0 @@
-from .squarenet import SquareNet 
-
-__all__ = ["SquareNet", "samplepoints", "place_at", "plotpoints", "sqplot", "carthesian_sort"]
-__version__ = "1.3.2"