docs: def fit_isophote(self, sma, step=0.1, conver=DEFAULT_CONVERGENCE,
                       minit=DEFAULT_MINIT, maxit=DEFAULT_MAXIT,
                       fflag=DEFAULT_FFLAG, maxgerr=DEFAULT_MAXGERR,
                       sclip=3., nclip=0, integrmode=BILINEAR,
                       linear=False, maxrit=None, noniterate=False,
                       going_inwards=False, isophote_list=None):
          """
          Fit a single isophote with a given semimajor axis length.
  
          The ``step`` and ``linear`` parameters are not used to actually
          grow or shrink the current fitting semimajor axis length.  They
          are necessary so the sampling algorithm can know where to start
          the gradient computation and also how to compute the elliptical
          sector areas (when area integration mode is selected).
  
          Parameters
          ----------
          sma : float
              The semimajor axis length (pixels).
          step : float, optional
              The step value used to grow/shrink the semimajor axis length
              (pixels if ``linear=True``, or a relative value if
              ``linear=False``). See the ``linear`` parameter.  The
              default is 0.1.
          conver : float, optional
              The main convergence criterion. Iterations stop when the
              largest harmonic amplitude becomes smaller (in absolute
              value) than ``conver`` times the harmonic fit rms.  The
              default is 0.05.
          minit : int, optional
              The minimum number of iterations to perform. A minimum of 10
              (the default) iterations guarantees that, on average, 2
              iterations will be available for fitting each independent
              parameter (the four harmonic amplitudes and the intensity
              level). For the first isophote, the minimum number of
              iterations is 2 * ``minit`` to ensure that, even departing
              from not-so-good initial values, the algorithm has a better
              chance to converge to a sensible solution.
          maxit : int, optional
              The maximum number of iterations to perform.  The default is
              50.
          fflag : float, optional
              The acceptable fraction of flagged data points in the
              sample.  If the actual fraction of valid data points is
              smaller than this, the iterations will stop and the current
              `~photutils.isophote.Isophote` will be returned.  Flagged
              data points are points that either lie outside the image
              frame, are masked, or were rejected by sigma-clipping.  The
              default is 0.7.
          maxgerr : float, optional
              The maximum acceptable relative error in the local radial
              intensity gradient.  When fitting a single isophote by
              itself this paramter doesn't have any effect on the outcome.
          sclip : float, optional
              The sigma-clip sigma value.  The default is 3.0.
          nclip : int, optional
              The number of sigma-clip interations.  The default is 0,
              which means sigma-clipping is skipped.
          integrmode : {'bilinear', 'nearest_neighbor', 'mean', 'median'}, optional
              The area integration mode.  The default is 'bilinear'.
          linear : bool, optional
              The semimajor axis growing/shrinking mode.  When fitting
              just one isophote, this parameter is used only by the code
              that define the details of how elliptical arc segments
              ("sectors") are extracted from the image when using area
              extraction modes (see the ``integrmode`` parameter).
          maxrit : float or `None`, optional
              The maximum value of semimajor axis to perform an actual
              fit.  Whenever the current semimajor axis length is larger
              than ``maxrit``, the isophotes will be extracted using the
              current geometry, without being fitted.  This non-iterative
              mode may be useful for sampling regions of very low surface
              brightness, where the algorithm may become unstable and
              unable to recover reliable geometry information.
              Non-iterative mode can also be entered automatically
              whenever the ellipticity exceeds 1.0 or the ellipse center
              crosses the image boundaries.  If `None` (default), then no
              maximum value is used.
          noniterate : bool, optional
              Whether the fitting algorithm should be bypassed and an
              isophote should be extracted with the geometry taken
              directly from the most recent `~photutils.isophote.Isophote`
              instance stored in the ``isophote_list`` parameter.  This
              parameter is mainly used when running the method in a loop
              over different values of semimajor axis length, and we want
              to change from iterative to non-iterative mode somewhere
              along the sequence of isophotes. When set to `True`, this
              parameter overrides the behavior associated with parameter
              ``maxrit``.  The default is `False`.
          going_inwards : bool, optional
              Parameter to define the sense of SMA growth. When fitting
              just one isophote, this parameter is used only by the code
              that defines the details of how elliptical arc segments
              ("sectors") are extracted from the image, when using area
              extraction modes (see the ``integrmode`` parameter).  The
              default is `False`.
          isophote_list : list or `None`, optional
              If not `None` (the default), the fitted
              `~photutils.isophote.Isophote` instance is appended to this
              list. It must be created and managed by the caller.
  
          Returns
          -------
          result : `~photutils.isophote.Isophote` instance
              The fitted isophote. The fitted isophote is also appended to
              the input list input to the ``isophote_list`` parameter.
          """
  
          geometry = self._geometry
  
          # if available, geometry from last fitted isophote will be
          # used as initial guess for next isophote.
          if isophote_list is not None and len(isophote_list) > 0:
              geometry = isophote_list[-1].sample.geometry
  
          # do the fit
          if noniterate or (maxrit and sma > maxrit):
              isophote = self._non_iterative(sma, step, linear, geometry,
                                             sclip, nclip, integrmode)
          else:
              isophote = self._iterative(sma, step, linear, geometry, sclip,
                                         nclip, integrmode, conver, minit,
                                         maxit, fflag, maxgerr, going_inwards)
  
          # store result in list
          if isophote_list is not None and isophote.valid:
              isophote_list.append(isophote)
  
          return isophote