docs: def magnification_finite(self, x_pos, y_pos, kwargs_lens, source_sigma=0.003, window_size=0.1, grid_number=100,
                               shape="GAUSSIAN", polar_grid=False, aspect_ratio=0.5):
          """
          returns the magnification of an extended source with Gaussian light profile
          :param x_pos: x-axis positons of point sources
          :param y_pos: y-axis position of point sources
          :param kwargs_lens: lens model kwargs
          :param source_sigma: Gaussian sigma in arc sec in source
          :param window_size: size of window to compute the finite flux
          :param grid_number: number of grid cells per axis in the window to numerically comute the flux
          :return: numerically computed brightness of the sources
          """
  
          mag_finite = np.zeros_like(x_pos)
          deltaPix = float(window_size)/grid_number
          if shape == 'GAUSSIAN':
              from lenstronomy.LightModel.Profiles.gaussian import Gaussian
              quasar = Gaussian()
          elif shape == 'TORUS':
              import lenstronomy.LightModel.Profiles.torus as quasar
          else:
              raise ValueError("shape %s not valid for finite magnification computation!" % shape)
          x_grid, y_grid = util.make_grid(numPix=grid_number, deltapix=deltaPix, subgrid_res=1)
  
          if polar_grid:
              a = window_size*0.5
              b = window_size*0.5*aspect_ratio
              ellipse_inds = (x_grid*a**-1) **2 + (y_grid*b**-1) **2 <= 1
              x_grid, y_grid = x_grid[ellipse_inds], y_grid[ellipse_inds]
  
          for i in range(len(x_pos)):
              ra, dec = x_pos[i], y_pos[i]
  
              center_x, center_y = self._lensModel.ray_shooting(ra, dec, kwargs_lens)
  
              if polar_grid:
                  theta = np.arctan2(dec,ra)
                  xcoord, ycoord = util.rotate(x_grid, y_grid, theta)
              else:
                  xcoord, ycoord = x_grid, y_grid
  
              betax, betay = self._lensModel.ray_shooting(xcoord + ra, ycoord + dec, kwargs_lens)
  
              I_image = quasar.function(betax, betay, 1., source_sigma, source_sigma, center_x, center_y)
              mag_finite[i] = np.sum(I_image) * deltaPix**2
  
          return mag_finite