code: def _skip_member(
      app: Sphinx,
      what: str,
      name: str,
      obj: Any,
      skip: bool,
      options: Any,
  ) -> bool | None:
      """Determine if private and special class members are included in docs.
  
      The following settings in conf.py determine if private and special class
      members or init methods are included in the generated documentation:
  
      * ``napoleon_include_init_with_doc`` --
        include init methods if they have docstrings
      * ``napoleon_include_private_with_doc`` --
        include private members if they have docstrings
      * ``napoleon_include_special_with_doc`` --
        include special members if they have docstrings
  
      Parameters
      ----------
      app : sphinx.application.Sphinx
          Application object representing the Sphinx process
      what : str
          A string specifying the type of the object to which the member
          belongs. Valid values: "module", "class", "exception", "function",
          "method", "attribute".
      name : str
          The name of the member.
      obj : module, class, exception, function, method, or attribute.
          For example, if the member is the __init__ method of class A, then
          `obj` will be `A.__init__`.
      skip : bool
          A boolean indicating if autodoc will skip this member if `_skip_member`
          does not override the decision
      options : sphinx.ext.autodoc.Options
          The options given to the directive: an object with attributes
          inherited_members, undoc_members, show_inheritance and no_index that
          are True if the flag option of same name was given to the auto
          directive.
  
      Returns
      -------
      bool
          True if the member should be skipped during creation of the docs,
          False if it should be included in the docs.
  
      """
      has_doc = getattr(obj, "__doc__", False)
      is_member = what in ("class", "exception", "module")
      if name != "__weakref__" and has_doc and is_member:
          cls_is_owner = False
          if what in ("class", "exception"):
              qualname = getattr(obj, "__qualname__", "")
              cls_path, _, _ = qualname.rpartition(".")
              if cls_path:
                  try:
                      if "." in cls_path:
                          import functools
                          import importlib
  
                          mod = importlib.import_module(obj.__module__)
                          mod_path = cls_path.split(".")
                          cls = functools.reduce(getattr, mod_path, mod)
                      else:
                          cls = inspect.unwrap(obj).__globals__[
                              cls_path
                          ]
                  except Exception:
                      cls_is_owner = False
                  else:
                      cls_is_owner = (
                          cls
                          and hasattr(cls, name)
                          and name  # type: ignore[assignment]
                          in cls.__dict__
                      )
              else:
                  cls_is_owner = False
  
          if what == "module" or cls_is_owner:
              is_init = name == "__init__"
              is_special = (
                  not is_init
                  and name.startswith("__")
                  and name.endswith("__")
              )
              is_private = (
                  not is_init
                  and not is_special
                  and name.startswith("_")
              )
              inc_init = app.config.napoleon_include_init_with_doc
              inc_special = app.config.napoleon_include_special_with_doc
              inc_private = app.config.napoleon_include_private_with_doc
              if (
                  (is_special and inc_special)
                  or (is_private and inc_private)
                  or (is_init and inc_init)
              ):
                  return False
      return None
  
file_path: sphinx/sphinx/ext/napoleon/__init__.py
imports: from __future__ import annotations
  from typing import TYPE_CHECKING, Any
  import sphinx
  from sphinx.application import Sphinx
  from sphinx.ext.napoleon.docstring import GoogleDocstring, NumpyDocstring
  from sphinx.util import inspect
label_desc: Use image node_id 4 for calling a global function with example usage: _skip_member(app, what, name, obj, skip, options) and returns: None, False