code: def search_light(
      X,
      y,
      estimator,
      A,
      groups=None,
      scoring=None,
      cv=None,
      n_jobs=-1,
      verbose=0,
  ):
      """Compute a search_light.
  
      Parameters
      ----------
      X : array-like of shape at least 2D
          data to fit.
  
      y : array-like
          target variable to predict.
  
      estimator : estimator object implementing 'fit'
          object to use to fit the data
  
      A : scipy sparse matrix.
          adjacency matrix. Defines for each feature the neigbhoring features
          following a given structure of the data.
  
      groups : array-like, optional, (default None)
          group label for each sample for cross validation.
  
          .. note::
              This will have no effect for scikit learn < 0.18
  
      scoring : string or callable, optional
          The scoring strategy to use. See the scikit-learn documentation
          for possible values.
          If callable, it takes as arguments the fitted estimator, the
          test data (X_test) and the test target (y_test) if y is
          not None.
  
      cv : cross-validation generator, optional
          A cross-validation generator. If None, a 3-fold cross
          validation is used or 3-fold stratified cross-validation
          when y is supplied.
      %(n_jobs_all)s
      %(verbose0)s
  
      Returns
      -------
      scores : array-like of shape (number of rows in A)
          search_light scores
      """
      group_iter = GroupIterator(A.shape[0], n_jobs)
      with warnings.catch_warnings():  # might not converge
          warnings.simplefilter("ignore", ConvergenceWarning)
          scores = Parallel(n_jobs=n_jobs, verbose=verbose)(
              delayed(_group_iter_search_light)(
                  A.rows[list_i],
                  estimator,
                  X,
                  y,
                  groups,
                  scoring,
                  cv,
                  thread_id + 1,
                  A.shape[0],
                  verbose,
              )
              for thread_id, list_i in enumerate(group_iter)
          )
      return np.concatenate(scores)
  
imports: import sys
  import time
  import warnings
  import numpy
  from joblib import Parallel, cpu_count, delayed
  from sklearn import svm
  from sklearn.base import BaseEstimator
  from sklearn.exceptions import ConvergenceWarning
  from sklearn.model_selection import cross_val_score
  from nilearn.maskers.nifti_spheres_masker import _apply_mask_and_get_affinity
  from ..None import masking
  from .._utils import check_niimg_4d, fill_doc
  from ..image.resampling import coord_transform
label_desc: Use image node_id 1 for calling a global function with example usage: search_light(X, y, estimator, A, groups, scoring, cv, n_jobs, verbose) and returns: np