docs: def get_sphinx_doc(
          self,
          name,
          depth=None,
          exclude=None,
          width=72,
          error=False,
          raised=False,
          no_comment=False,
      ):
          r"""
          Return an exception list marked up in `reStructuredText`_.
  
          :param name: Name of the callable (method, function or class
                       property) to generate exceptions documentation for
          :type  name: string
  
          :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]*)
          """
          # pylint: disable=R0101,R0204,R0912,R0915,R0916
          if depth and (
              (not isinstance(depth, int)) or (isinstance(depth, int) and (depth < 0))
          ):
              raise RuntimeError("Argument `depth` is not valid")
          if exclude and (
              (not isinstance(exclude, list))
              or (
                  isinstance(exclude, list)
                  and any([not isinstance(item, str) for item in exclude])
              )
          ):
              raise RuntimeError("Argument `exclude` is not valid")
          if (not isinstance(width, int)) or (
              isinstance(width, int) and (width < _MINWIDTH)
          ):
              raise RuntimeError("Argument `width` is not valid")
          if not isinstance(error, bool):
              raise RuntimeError("Argument `error` is not valid")
          if not isinstance(raised, bool):
              raise RuntimeError("Argument `raised` is not valid")
          if not isinstance(no_comment, bool):
              raise RuntimeError("Argument `raised` is not valid")
          depth = self._depth if depth is None else depth
          exclude = self._exclude if not exclude else exclude
          callable_dict = {}
          prop = False
          # Try to find "regular" callable. The trace may have several calls
          # to the same callable, capturing potentially different exceptions
          # or behaviors, thus capture them all
          instances = self._tobj.search_tree(name)
          if instances:
              callable_dict[name] = {"type": "regular", "instances": instances}
          else:
              # Try to find property callable
              for action in ["getter", "setter", "deleter"]:
                  prop_name = "{name}({action})".format(name=name, action=action)
                  instances = self._tobj.search_tree(prop_name)
                  if instances:
                      callable_dict[prop_name] = {"type": action, "instances": instances}
                      prop = True
          if error and (not callable_dict):
              raise RuntimeError(
                  "Callable not found in exception list: {callable}".format(callable=name)
              )
          if not callable_dict:
              # Callable did not register any exception
              return ""
          # Create exception table using depth, exclude and raised arguments
          sep = self._tobj.node_separator
          dkeys = []
          for key, name_dict in callable_dict.items():
              exlist = []
              for callable_root in name_dict["instances"]:
                  # Find callable tree depth, this is the reference
                  # level (depth=0) for the depth argument
                  rlevel = callable_root[: callable_root.index(name)].count(sep)
                  # Create a list of tuples with the full node name of each node
                  # that contains the callable name (to find exceptions in tree)
                  # and the path underneath the callable appearance on the
                  # callable tree, split by tree path separator (to determine if
                  # exception should be added based on depth and exclusion list
                  nodes = self._tobj.get_subtree(callable_root)
                  tnodes = [(node, sep.join(node.split(sep)[rlevel:])) for node in nodes]
                  for fnode, rnode in tnodes:
                      data = self._tobj._get_data(fnode)
                      if (
                          data
                          and (
                              (depth is None)
                              or ((depth is not None) and (rnode.count(sep) <= depth))
                          )
                          and (
                              (not exclude)
                              or (not any([item in rnode for item in exclude]))
                          )
                      ):
                          for exc in data:
                              msg = self._process_exlist(exc, raised)
                              if msg is not None:
                                  exlist.append(msg)
              if exlist:
                  name_dict["exlist"] = list(set(exlist[:]))
              else:
                  # A callable can have registered exceptions but none of them
                  # may meet the depth and exclude specification, in this case
                  # the entry should be deleted from the dictionary
                  dkeys.append(key)
          for key in dkeys:
              del callable_dict[key]
          if not callable_dict:
              # Callable had registered exceptions but not a single one of those
              # was raised
              return ""
          # Generate final output
          if no_comment:
              exoutput = [""]
          else:
              template = ".. Auto-generated exceptions documentation for {callable}"
              exoutput = [
                  _format_msg(template.format(callable=name), width, prefix=".. ")
              ]
              exoutput.extend([""])
          desc_dict = {"getter": "retrieved", "setter": "assigned", "deleter": "deleted"}
          if prop:
              if len(callable_dict) == 1:
                  # For a property that raises exceptions on one and only one
                  # action (set, get or delete) the format when there is only
                  # one exception is (with get as an example action):
                  # :raises: (when retrieved) RuntimeError (Invalid option)
                  # If there are multiple exceptions:
                  # :raises: (when retrieved)
                  #
                  #    * RuntimeError (Invalid options)
                  #
                  #    * TypeError (Wrong type)
                  callable_root = next(iter(callable_dict))
                  action = callable_dict[callable_root]["type"]
                  desc = desc_dict[action]
                  exlist = set(callable_dict[callable_root]["exlist"])
                  exlength = len(exlist)
                  indent = 1 if exlength == 1 else 3
                  template = ":raises: (when {action})\n\n".format(action=desc)
                  prefix = (template.strip() + " ") if exlength == 1 else " * "
                  fexlist = [
                      _format_msg(
                          "{prefix}{name}".format(prefix=prefix, name=name), width, indent
                      )
                      for name in sorted(list(exlist))
                  ]
                  exoutput.extend(
                      [(template if exlength > 1 else "") + "\n\n".join(fexlist)]
                  )
              else:
                  # For a property that raises exceptions on more than one
                  # action (set, get or delete) the format is:
                  # :raises:
                  #  * When assigned:
                  #
                  #    * RuntimeError (Invalid options)
                  #
                  #    * TypeError (Wrong type)
                  #
                  #  * When retrieved:
                  #
                  #    * RuntimeError (Null object)
                  exoutput.append(":raises:")
                  for action in ["setter", "deleter", "getter"]:
                      desc = desc_dict[action]
                      for callable_root in callable_dict:
                          if callable_dict[callable_root]["type"] == action:
                              exlist = set(callable_dict[callable_root]["exlist"])
                              fexlist = [
                                  _format_msg("   * {name}".format(name=name), width, 5)
                                  for name in sorted(list(exlist))
                              ]
                              exoutput.extend(
                                  [
                                      " * When {action}\n\n".format(action=desc)
                                      + "\n\n".join(fexlist)
                                      + "\n"
                                  ]
                              )
          else:
              # For a regular callable (function or method) that raises only
              # one exception the format is:
              # :raises: RuntimeError (Invalid options)
              # For a regular callable (function or method) that raises multiple
              # exceptions the format is:
              # :raises:
              #  * RuntimeError (Invalid options)
              #
              #  * RuntimeError (Null object)
              exlist = set(callable_dict[next(iter(callable_dict))]["exlist"])
              exlength = len(exlist)
              indent = 1 if exlength == 1 else 3
              prefix = ":raises: " if exlength == 1 else " * "
              fexlist = [
                  _format_msg(
                      "{prefix}{name}".format(prefix=prefix, name=name), width, indent
                  )
                  for name in sorted(list(exlist))
              ]
              exoutput.extend(
                  [(":raises:\n" if exlength > 1 else "") + "\n\n".join(fexlist)]
              )
          exoutput[-1] = "{line}\n\n".format(line=exoutput[-1].rstrip())
          return ("\n".join(exoutput)) if exoutput else ""