code: def compute_proj_raw(
      raw,
      start=0,
      stop=None,
      duration=1,
      n_grad=2,
      n_mag=2,
      n_eeg=0,
      reject=None,
      flat=None,
      n_jobs=None,
      meg="separate",
      verbose=None,
  ):
      """Compute SSP (signal-space projection) vectors on continuous data.
  
      %(compute_ssp)s
  
      Parameters
      ----------
      raw : instance of Raw
          A raw object to use the data from.
      start : float
          Time (in seconds) to start computing SSP.
      stop : float | None
          Time (in seconds) to stop computing SSP. None will go to the end of the file.
      duration : float | None
          Duration (in seconds) to chunk data into for SSP
          If duration is ``None``, data will not be chunked.
      %(n_proj_vectors)s
      reject : dict | None
          Epoch PTP rejection threshold used if ``duration != None``. See `~mne.Epochs`.
      flat : dict | None
          Epoch flatness rejection threshold used if ``duration != None``. See
          `~mne.Epochs`.
      %(n_jobs)s
          Number of jobs to use to compute covariance.
      meg : str
          Can be ``'separate'`` (default) or ``'combined'`` to compute projectors
          for magnetometers and gradiometers separately or jointly.
          If ``'combined'``, ``n_mag == n_grad`` is required and the number of
          projectors computed for MEG will be ``n_mag``.
  
          .. versionadded:: 0.18
      %(verbose)s
  
      Returns
      -------
      projs: list of Projection
          List of projection vectors.
  
      See Also
      --------
      compute_proj_epochs, compute_proj_evoked
      """
      if duration is not None:
          duration = (
              np.round(duration * raw.info["sfreq"]) / raw.info["sfreq"]
          )
          events = make_fixed_length_events(
              raw, 999, start, stop, duration
          )
          picks = pick_types(
              raw.info,
              meg=True,
              eeg=True,
              eog=True,
              ecg=True,
              emg=True,
              exclude="bads",
          )
          epochs = Epochs(
              raw,
              events,
              None,
              tmin=0.0,
              tmax=duration - 1.0 / raw.info["sfreq"],
              picks=picks,
              reject=reject,
              flat=flat,
              baseline=None,
              proj=False,
          )
          data = _compute_cov_epochs(epochs, n_jobs)
          info = epochs.info
          if not stop:
              stop = raw.n_times / raw.info["sfreq"]
      else:
          # convert to sample indices
          start = max(raw.time_as_index(start)[0], 0)
          stop = raw.time_as_index(stop)[0] if stop else raw.n_times
          stop = min(stop, raw.n_times)
          data, times = raw[:, start:stop]
          _check_n_samples(stop - start, data.shape[0])
          data = np.dot(data, data.T)  # compute data covariance
          info = raw.info
          # convert back to times
          start = start / raw.info["sfreq"]
          stop = stop / raw.info["sfreq"]
  
      desc_prefix = "Raw-%-.3f-%-.3f" % (start, stop)
      projs = _compute_proj(
          data, info, n_grad, n_mag, n_eeg, desc_prefix, meg=meg
      )
      return projs
  
imports: import numpy
  from ._fiff.constants import FIFF
  from ._fiff.open import fiff_open
  from ._fiff.pick import _picks_to_idx, pick_types, pick_types_forward
  from ._fiff.proj import Projection, _has_eeg_average_ref_proj, _read_proj, _write_proj, make_eeg_average_ref_proj, make_projector
  from ._fiff.write import start_and_end_file
  from .cov import _check_n_samples
  from .epochs import Epochs
  from .event import make_fixed_length_events
  from .fixes import _safe_svd
  from .forward import _subject_from_forward, convert_forward_solution, is_fixed_orient
  from .parallel import parallel_func
  from .source_estimate import _make_stc
  from .utils import _check_fname, _check_option, _validate_type, check_fname, logger, verbose
label_desc: Use image node_id 7 for calling a global function with example usage: compute_proj_raw(raw, start, stop, duration, n_grad, n_mag, n_eeg, reject, flat, n_jobs, meg, verbose) and returns: projs