docs: def get_sphinx_autodoc(
          self,
          depth=None,
          exclude=None,
          width=72,
          error=False,
          raised=False,
          no_comment=False,
      ):
          r"""
          Return exception list in `reStructuredText`_ auto-determining callable name.
  
          :param depth: Hierarchy levels to include in the exceptions list
                        (overrides default **depth** argument; see
                        :py:attr:`pexdoc.ExDoc.depth`). If None exceptions
                        at all depths are included
          :type  depth: non-negative integer or None
  
          :param exclude: List of (potentially partial) module and callable
                          names to exclude from exceptions list  (overrides
                          default **exclude** argument, see
                          :py:attr:`pexdoc.ExDoc.exclude`). If None all
                          callables are included
          :type  exclude: list of strings or None
  
          :param width: Maximum width of the lines of text (minimum 40)
          :type  width: integer
  
          :param error: Flag that indicates whether an exception should be
                        raised if the callable is not found in the callables
                        exceptions database (True) or not (False)
          :type  error: boolean
  
          :param raised: Flag that indicates whether only exceptions that
                         were raised (and presumably caught) should be
                         documented (True) or all registered exceptions should
                         be documented (False)
  
          :type  raised: boolean
  
          :param no_comment: Flag that indicates whether a `reStructuredText`_
                             comment labeling the callable (method, function or
                             class property) should be printed (False) or not
                             (True) before the exceptions documentation
          :type  no_comment: boolean
  
          :raises:
  
           * RuntimeError (Argument \\`depth\\` is not valid)
  
           * RuntimeError (Argument \\`error\\` is not valid)
  
           * RuntimeError (Argument \\`exclude\\` is not valid)
  
           * RuntimeError (Argument \\`no_comment\\` is not valid)
  
           * RuntimeError (Argument \\`raised\\` is not valid)
  
           * RuntimeError (Argument \\`width\\` is not valid)
  
           * RuntimeError (Callable not found in exception list: *[name]*)
  
           * RuntimeError (Unable to determine callable name)
          """
          # This code is cog-specific: cog code file name is the module
          # file name, a plus (+), and then the line number where the
          # cog function is
          frame = sys._getframe(1)
          index = frame.f_code.co_filename.rfind("+")
          fname = os.path.abspath(frame.f_code.co_filename[:index])
          # Find name of callable based on module name and line number
          # within that module, then get the exceptions by using the
          # get_sphinx_doc() method with this information
          line_num = int(frame.f_code.co_filename[index + 1 :])
          module_db = self._module_obj_db[fname]
          names = [callable_dict["name"] for callable_dict in module_db]
          line_nums = [callable_dict["line"] for callable_dict in module_db]
          name = names[bisect.bisect(line_nums, line_num) - 1]
          return self.get_sphinx_doc(
              name=name,
              depth=depth,
              exclude=exclude,
              width=width,
              error=error,
              raised=raised,
              no_comment=no_comment,
          )