perf: defer scipy imports to reduce import time

Move scipy imports from module level to local function scope in
convolver, delaunay interpolator, mask utilities, cholesky, and fnnls
modules. This avoids loading scipy during `import autoarray`, cutting
~0.3s from the import floor in smoke tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

autoarray/inversion/inversion/inversion_util.py

@@ -5,7 +5,6 @@
 from autoarray.settings import Settings
 
 from autoarray import exc
-from autoarray.util.fnnls import fnnls_cholesky
 
 
 def curvature_matrix_diag_via_psf_weighted_noise_from(
@@ -281,6 +280,8 @@ def reconstruction_positive_only_from(
 
     try:
 
+        from autoarray.util.fnnls import fnnls_cholesky
+
         return fnnls_cholesky(
             curvature_reg_matrix,
             (data_vector).T,

autoarray/inversion/mesh/interpolator/delaunay.py

@@ -1,6 +1,4 @@
 import numpy as np
-import scipy.spatial
-from scipy.spatial import cKDTree, Delaunay, Voronoi
 
 from autoconf import cached_property
 
@@ -12,6 +10,7 @@
 
 def scipy_delaunay(points_np, query_points_np, areas_factor):
     """Compute Delaunay simplices (simplices_padded) and Voronoi areas in one call."""
+    from scipy.spatial import Delaunay
 
     max_simplices = 2 * points_np.shape[0]
 
@@ -182,6 +181,8 @@ def pix_indexes_for_sub_slim_index_delaunay_from(
     # Case 2: Outside → KDTree NN
     # ---------------------------
     if outside_mask.any():
+        from scipy.spatial import cKDTree
+
         tree = cKDTree(delaunay_points)
         _, idx = tree.query(data_grid[outside_mask], k=1)
         out[outside_mask, 0] = idx.astype(np.int32)
@@ -202,6 +203,7 @@ def scipy_delaunay_matern(points_np, query_points_np):
         typically of shape (Q, 3), where each row gives the indices of the
         Delaunay mesh vertices ("pixels") associated with that query point.
     """
+    from scipy.spatial import Delaunay
 
     max_simplices = 2 * points_np.shape[0]
 

autoarray/mask/mask_2d_util.py

@@ -1,6 +1,5 @@
 import numpy as np
 import warnings
-from scipy.ndimage import binary_dilation
 from typing import Tuple
 
 from autoarray import exc
@@ -465,7 +464,6 @@ def min_false_distance_to_edge(mask: np.ndarray) -> Tuple[int, int]:
 from typing import Tuple
 
 import numpy as np
-from scipy.ndimage import binary_dilation
 
 
 def required_shape_for_kernel(
@@ -608,6 +606,8 @@ def blurring_mask_2d_from(
     )
 
     # Pixels within kernel footprint of any unmasked pixel
+    from scipy.ndimage import binary_dilation
+
     near_unmasked_padded = binary_dilation(unmasked_padded, structure=structure)
     near_unmasked = near_unmasked_padded[
         pad_y : pad_y + mask_2d.shape[0],

autoarray/operators/convolver.py

@@ -7,7 +7,6 @@
 
 import numpy as np
 from pathlib import Path
-import scipy
 from typing import Optional, Tuple, Union
 import warnings
 
@@ -116,6 +115,8 @@ class determines how masked real-space data are embedded into a padded array,
         full_shape = tuple(
             s1 + s2 - 1 for s1, s2 in zip(mask_shape, self.kernel.shape_native)
         )
+        import scipy.fft
+
         fft_shape = tuple(scipy.fft.next_fast_len(s, real=True) for s in full_shape)
 
         self.fft_shape = fft_shape

autoarray/util/cholesky_funcs.py

@@ -1,5 +1,4 @@
 import numpy as np
-from scipy import linalg
 import math
 import time
 from autoarray import numba_util
@@ -46,6 +45,8 @@ def _cholupdate(U, x):
 
 
 def cholinsert(U, index, x):
+    from scipy import linalg
+
     S = np.insert(np.insert(U, index, 0, axis=0), index, 0, axis=1)
 
     S[:index, index] = S12 = linalg.solve_triangular(
@@ -70,6 +71,8 @@ def cholinsertlast(U, x):
     As in current Cholesky scheme implemented in fnnls, we only use this kind of insertion, so I
         separate it out from the `cholinsert`.
     """
+    from scipy import linalg
+
     index = U.shape[0]
 
     S = np.insert(np.insert(U, index, 0, axis=0), index, 0, axis=1)

autoarray/util/fnnls.py

@@ -1,5 +1,4 @@
 import numpy as np
-from scipy import linalg as slg
 
 from autoarray.util.cholesky_funcs import cholinsertlast, choldeleteindexes
 
@@ -27,6 +26,7 @@ def fnnls_cholesky(
     """
     Similar to fnnls, but use solving the lstsq problem by updating Cholesky factorisation.
     """
+    from scipy import linalg as slg
 
     lstsq = lambda A, x: slg.solve(
         A,
@@ -147,6 +147,8 @@ def fix_constraint_cholesky(ZTx, s_chol, d, P, P_inorder, U, tolerance):
     # solve the lstsq problem by cho_solve
 
     if len(P_inorder):
+        from scipy import linalg as slg
+
         # there could be a case where P_inorder is empty.
         s_chol[P_inorder] = slg.cho_solve((U, False), ZTx[P_inorder])