def importfile(path: str) -> TypeLike:
    """Import a Python source file or compiled file given its path."""
    magic = importlib.util.MAGIC_NUMBER
    with open(path, "rb") as file:
        is_bytecode = magic == file.read(len(magic))
    filename = os.path.basename(path)
    name, _ = os.path.splitext(filename)
    if is_bytecode:
        loader = importlib._bootstrap_external.SourcelessFileLoader(name, path)
    else:
        loader = importlib._bootstrap_external.SourceFileLoader(name, path)
    # XXX We probably don't need to pass in the loader here.
    spec = importlib.util.spec_from_file_location(name, path, loader=loader)
    try:
        return cast(TypeLike, importlib._bootstrap._load(spec))
    # pylint: disable=broad-except
    except BaseException as import_error:
        LOGGER.warning(f"Skipping importfile for {name} at {path}, got a {import_error}")
        raise ImportTimeError(path, sys.exc_info()) from import_error

def ispackage(path: str) -> bool:
    """Guess whether a path refers to a package directory."""
    if os.path.isdir(path):
        for ext in (".py", ".pyc"):
            if os.path.isfile(os.path.join(path, "__init__" + ext)):
                return True
    return False

def locate(path: str, force_load: bool = False) -> Any:
    """Locate an object by name or dotted path, importing as necessary."""
    if "-" in path:
        # Not sure about this
        path = path.replace("-", "_")

    LOGGER.debug(f"locate(): locating {path}")
    parts = [part for part in path.split(".") if part]

    module, index = None, 0
    while index < len(parts):
        next_module = safe_import(".".join(parts[: index + 1]), force_load)
        if next_module:
            module, index = next_module, index + 1
        else:
            break
    if module:
        the_object = module
        # this errors?!
        # LOGGER.debug(f"putative module {str(the_object)}")
    else:
        the_object = builtins

    for part in parts[index:]:
        try:
            the_object = getattr(the_object, part)
        except AttributeError:
            LOGGER.debug(f"locate(): Don't think this is a module {the_object}")
            return None
    return the_object

def safe_import(
    path: str,
    force_load: bool = False,
    cache: Dict[str, Any] = {},  # noqa - this is mutable on purpose!
) -> Any:
    """
    Import a module; handle errors; return None if the module isn't found.

    If the module *is* found but an exception occurs, it's wrapped in an
    ErrorDuringImport exception and reraised.  Unlike __import__, if a
    package path is specified, the module at the end of the path is returned,
    not the package at the beginning.  If the optional 'force_load' argument
    is True, we reload the module from disk (unless it's a dynamic extension).
    """
    try:
        # If force_load is True and the module has been previously loaded from
        # disk, we always have to reload the module.  Checking the file's
        # mtime isn't good enough (e.g. the module could contain a class
        # that inherits from another module that has changed).
        if force_load and path in sys.modules:
            if path not in sys.builtin_module_names:
                # Remove the module from sys.modules and re-import to try
                # and avoid problems with partially loaded modules.
                # Also remove any submodules because they won't appear
                # in the newly loaded module's namespace if they're already
                # in sys.modules.
                subs = [m for m in sys.modules if m.startswith(path + ".")]
                for key in [path] + subs:
                    # Prevent garbage collection.
                    cache[key] = sys.modules[key]
                    del sys.modules[key]
        module = __import__(path)
    # pylint: disable=broad-except
    except BaseException as import_error:
        # Did the error occur before or after the module was found?
        (exc, value, _) = info = sys.exc_info()
        if path in sys.modules:
            # An error occurred while executing the imported module.
            LOGGER.warning(f"Skipping safe_import for {path}, got a {import_error}")
            raise ImportTimeError(sys.modules[path].__file__, info) from import_error
        if exc is SyntaxError:
            # A SyntaxError occurred before we could execute the module.
            # MR : this isn't null safe.
            LOGGER.warning(f"Skipping safe_import for {path}, got a {str(exc)}")
            raise ImportTimeError(
                cast(SyntaxError, value).filename, info
            ) from import_error
        if issubclass(exc, ImportError) and cast(ImportError, value).name == path:
            LOGGER.warning(f"Skipping safe_import for {path}, got a {import_error}")
            LOGGER.warning(f"Cannot import this path: {path}")
            # No such module in the path.
            return None
        LOGGER.warning(f"Skipping safe_import for {path}, got a {import_error}")
        # Some other error occurred during the importing process.
        raise ImportTimeError(path, sys.exc_info()) from import_error
    for part in path.split(".")[1:]:
        try:
            module = getattr(module, part)
        except AttributeError:
            LOGGER.warning(f"While safe_import - {str(module)} does not have {part} from dot path {path}")
            return None
    return module

def locate_file(file_name: str, executing_file: str) -> str:
    """
    Find file relative to a source file, e.g.
    locate_file("foo/bar.txt", __file__)

    Succeeds regardless to context of execution
    """
    file_path = os.path.join(
        os.path.dirname(os.path.abspath(executing_file)), file_name
    )
    return file_path

def classify_class_attrs(the_object: TypeLike) -> List[Tuple[str, str, type, object]]:
    """Wrap inspect.classify_class_attrs, with fixup for data descriptors."""
    results = []
    try:
        for (name, kind, cls, value) in inspect.classify_class_attrs(
            cast(type, the_object)
        ):
            if inspect.isdatadescriptor(value):
                kind = "data descriptor"
                if isinstance(value, property) and value.fset is None:
                    kind = "readonly property"
            results.append((name, kind, cls, value))
    except ValueError:
        LOGGER.warning(f"Skipping classify_class_attrs for {str(the_object)} got ValueError, maybe this is a Namespace")
        # py._xmlgen.Namespace
        # ValueError: Namespace class is abstract
    return results

def classname(the_object: TypeLike, modname: str) -> str:
    """Get a class name and qualify it with a module name if necessary."""
    name = the_object.__name__
    if the_object.__module__ != modname:
        name = the_object.__module__ + "." + name
    return name

def describe(thing: TypeLike) -> str:
    """Produce a short description of the given thing."""
    if inspect.ismodule(thing):
        if thing.__name__ in sys.builtin_module_names:
            return "built-in module " + thing.__name__
        if hasattr(thing, "__path__"):
            return "package " + thing.__name__
        return "module " + thing.__name__
    if inspect.isbuiltin(thing):
        return "built-in function " + thing.__name__
    if inspect.isgetsetdescriptor(thing):
        return f"getset descriptor {thing.__objclass__.__module__}.{thing.__objclass__.__name__}.{thing.__name__}"
    if inspect.ismemberdescriptor(thing):
        return f"member descriptor {thing.__objclass__.__module__}.{thing.__objclass__.__name__}.{thing.__name__}"
    if inspect.isclass(thing):
        return "class " + thing.__name__
    if inspect.isfunction(thing):
        return "function " + thing.__name__
    if inspect.ismethod(thing):
        return "method " + thing.__name__
    return type(thing).__name__

def getdoc(the_object: TypeLike) -> str:
    """Get the doc string or comments for an object."""
    result = _getdoc(the_object) or inspect.getcomments(the_object)
    return result and re.sub("^ *\n", "", result.rstrip()) or ""

def isdata(the_object: Any) -> bool:
    """Check if an object is of a type that probably means it's data."""
    return not (
        inspect.ismodule(the_object)
        or inspect.isclass(the_object)
        or inspect.isroutine(the_object)
        or inspect.isframe(the_object)
        or inspect.istraceback(the_object)
        or inspect.iscode(the_object)
    )

def resolve(thing: Union[str, Any], force_load: bool = False) -> Tuple[Any, Any]:
    """Given an object or a path to an object, get the object and its name."""
    if isinstance(thing, str):
        the_object = locate(thing, force_load)
        if the_object is None:

            raise ImportError(
                """\
No Python documentation found for %r."""
                % thing
            )
        return the_object, thing

    name = getattr(thing, "__name__", None)
    if isinstance(name, str):
        return thing, name
    return thing, str(thing)  # HACK

def sort_attributes(attrs: List[Any], the_object: Union[TypeLike, type]) -> None:
    """Sort the attrs list in-place by _fields and then alphabetically by name"""
    # This allows data descriptors to be ordered according
    # to a _fields attribute if present.
    fields = getattr(the_object, "_fields", [])
    try:
        field_order = {name: i - len(fields) for (i, name) in enumerate(fields)}
    except TypeError:
        field_order = {}

    def key_function(attr: List[Any]) -> Tuple[Any, Any]:
        """Sorting function"""
        return field_order.get(attr[0], 0), attr[0]

    attrs.sort(key=key_function)

def visiblename(
    name: str, all_things: Optional[List[str]] = None, obj: Optional[Any] = None
) -> bool:
    """Decide whether to show documentation on a variable."""
    # Certain special names are redundant or internal.
    # XXX Remove __initializing__?
    if name in {
        # people use these for all sorts of things
        # "__author__",
        # "__credits__",
        # "__date__",
        # "__version__",
        #
        # These are internal implementation details USUALLY
        "__builtins__",
        "__cached__",
        "__doc__",
        "__file__",
        "__spec__",
        "__loader__",
        "__module__",
        "__name__",
        "__package__",
        "__path__",
        "__qualname__",
        "__slots__",
        "__dict__",
        "__weakref__",
    }:
        return False
    # Private names are hidden, but special names are displayed.
    if name.startswith("__") and name.endswith("__"):
        return True
    # Namedtuples have public fields and methods with a single leading underscore
    if name.startswith("_") and hasattr(obj, "_fields"):
        return True
    if all_things is not None:
        # only document that which the programmer exported in __all__
        return name in all_things
    return not name.startswith("_")

def classlink(the_object: Union[TypeLike, type], modname: str) -> str:
    """Make a link for a class."""
    name, module = the_object.__name__, sys.modules.get(the_object.__module__)
    if hasattr(module, name) and getattr(module, name) is the_object:
        return f'<a href="{module.__name__}.html#{name}">{classname(cast(TypeLike, the_object), modname)}</a>'
    return classname(the_object, modname)

def docclass(
    the_object: TypeLike,
    name: str = "",
    mod: str = "",
    funcs: Optional[Dict[str, str]] = None,
    classes: Optional[Dict[str, str]] = None,
) -> str:
    """Produce HTML documentation for a class object."""
    funcs = funcs or {}
    classes = classes or {}

    real_name = the_object.__name__
    name = name or real_name
    bases = the_object.__bases__

    contents: List[str] = []
    push = contents.append

    class HorizontalRule:
        """Cute little class to pump out a horizontal rule between sections."""

        def __init__(self) -> None:
            self.need_one = 0

        def maybe(self) -> None:
            """Skip"""
            if self.need_one:
                push("<hr>\n")
            self.need_one = 1

    # pylint:disable=invalid-name
    hr = HorizontalRule()

    # List the mro, if non-trivial.
    mro = deque(inspect.getmro(cast(type, the_object)))
    if len(mro) > 2:
        hr.maybe()
        push("<dl><dt>Method resolution order:</dt>\n")
        for base in mro:
            push(f"<dd>{classlink(base, the_object.__module__)}</dd>\n")
        push("</dl>\n")

    def spill(
        msg: str, attrs_in: List[Any], predicate: Callable[[Any], Any]
    ) -> List[Any]:
        """Not sure"""
        ok, attrs = _split_list(attrs_in, predicate)
        if ok:
            hr.maybe()
            push(msg)
            for name, _, _, value in ok:
                # noinspection PyBroadException
                try:
                    value = getattr(the_object, name)
                except Exception:  # nosec
                    # Some descriptors may meet a failure in their __get__.
                    # (bug #1785)
                    push(
                        document_data(
                            value,
                            name,
                            # mod, unused
                        )
                    )
                else:
                    # circular ref
                    # pylint: disable=import-outside-toplevel
                    from pydoc_fork.reporter.format_page import document

                    push(
                        document(
                            value, name, mod, funcs, classes, module_dict, the_object
                        )
                    )
                push("\n")
        return attrs

    def spilldescriptors(
        msg: str,
        attrs_in: List[Any],  # Tuple[str, str, type, "object"]
        predicate: Callable[[Any], bool],
    ) -> List[Any]:
        """Not sure"""
        ok, attrs = _split_list(attrs_in, predicate)
        if ok:
            hr.maybe()
            push(msg)
            for name, _, _, value in ok:
                push(
                    document_data(
                        value,
                        name,
                        # mod, ignored
                    )
                )
        return attrs

    def spilldata(
        msg: str, attrs_in: List[Any], predicate: Callable[[Any], bool]
    ) -> List[Any]:
        """Not sure"""
        ok, attrs = _split_list(attrs_in, predicate)
        if ok:
            hr.maybe()
            push(msg)
            for name, _, __, value in ok:
                base = docother(
                    getattr(the_object, name),
                    name,
                    # mod ignored
                )
                found_doc = getdoc(value)
                if not found_doc:
                    push(f"<dl><dt>{base}</dl>\n")
                else:
                    found_doc = markup(getdoc(value), funcs, classes, module_dict)
                    found_doc = f"<dd><tt>{found_doc}</tt>"
                    push(f"<dl><dt>{base}{found_doc}</dl>\n")
                push("\n")
        return attrs

    attrs = [
        (name, kind, cls, value)
        for name, kind, cls, value in classify_class_attrs(the_object)
        if visiblename(name, obj=the_object)
    ]

    module_dict = {}
    for key, _, _, value in attrs:
        module_dict[key] = anchor = "#" + name + "-" + key
        try:
            value = getattr(the_object, name)
        except Exception:  # nosec
            # Some descriptors may meet a failure in their __get__.
            # (bug #1785)
            pass  # nosec
        try:
            # The value may not be hashable (e.g., a data attr with
            # a dict or list value).
            module_dict[value] = anchor
        except TypeError:
            pass  # nosec

    while attrs:
        if mro:
            this_class = mro.popleft()
        else:
            this_class = attrs[0][2]

        is_this_class: Callable[[Any], Any] = lambda t: t[2] is this_class
        attrs, inherited = _split_list(attrs, is_this_class)

        if the_object is not builtins.object and this_class is builtins.object:
            attrs = inherited
            continue
        if this_class is the_object:
            tag = "defined here"
        else:
            tag = f"inherited from {classlink(this_class, the_object.__module__)}"
        tag += ":<br>\n"

        sort_attributes(attrs, the_object)

        # feature to remove typing annotations cruft.
        for kind in attrs.copy():
            module_name = inspect.getmodule(kind)
            if module_name and module_name.__name__ in settings.SKIP_MODULES:
                attrs.remove(kind)

        # Pump out the attrs, segregated by kind.
        is_method: Callable[[Any], Any] = lambda t: t[1] == "method"
        attrs = spill(f"Methods {tag}", attrs, is_method)
        is_class: Callable[[Any], Any] = lambda t: t[1] == "class method"
        attrs = spill(f"Class methods {tag}", attrs, is_class)
        is_static: Callable[[Any], Any] = lambda t: t[1] == "static method"
        attrs = spill(f"Static methods {tag}", attrs, is_static)
        is_read_only: Callable[[Any], Any] = lambda t: t[1] == "readonly property"
        attrs = spilldescriptors(
            f"Readonly properties {tag}",
            attrs,
            is_read_only,
        )
        is_data_descriptor: Callable[[Any], Any] = lambda t: t[1] == "data descriptor"
        attrs = spilldescriptors(f"Data descriptors {tag}", attrs, is_data_descriptor)
        is_data: Callable[[Any], Any] = lambda t: t[1] == "data"
        attrs = spilldata(f"Data and other attributes {tag}", attrs, is_data)
        assert not attrs  # nosec
        attrs = inherited

    contents_as_string = "".join(contents)  # type got redefined

    if name == real_name:
        title = f'<a name="{name}">class <strong>{real_name}</strong></a>'
    else:
        title = f'<strong>{name}</strong> = <a name="{name}">class {real_name}</a>'
    if bases:
        parents = []
        for base in bases:
            parents.append(classlink(base, the_object.__module__))
        title = title + f"({', '.join(parents)})"

    decl = ""
    try:
        signature = inspect.signature(the_object)
    except (ValueError, TypeError):
        signature = None
    if signature:
        argument_specification = str(signature)
        if argument_specification and argument_specification != "()":
            # this will cause double escape on ->
            # escape(argument_specification)
            decl = name + argument_specification + "\n\n"

    doc = getdoc(the_object)
    if decl:
        doc = decl + (doc or "")
    doc = markup(doc, funcs, classes, module_dict)
    doc = doc and f"<tt>{doc}<br>&nbsp;</tt>"

    return section(title, "#000000", "#ffc8d8", contents_as_string, 3, doc)

def format_tree(tree: List[Any], modname: str, parent: Optional[Any] = None) -> str:
    """
    Creates a representation of class inheritance.
    """

    # """Produce HTML for a class tree as given by inspect.getclasstree()."""
    result = ""
    for entry in tree:
        class_object = entry
        # pylint: disable=unidiomatic-typecheck
        if type(entry) is type(()):  # noqa - not sure of switching to isinstance
            class_object, bases = entry
            result = (
                result + f'<dt><span style="font-family:{inline_styles.SAN_SERIF}">'
            )
            result = result + classlink(class_object, modname)
            if bases and bases != (parent,):
                parents = []
                for base in bases:
                    parents.append(classlink(base, modname))
                result = result + "(" + ", ".join(parents) + ")"
            result = result + "\n</span></dt>"

        elif type(entry) is type([]):  # noqa - not sure of switching to isinstance
            tree = format_tree(entry, modname, class_object)
            result = result + f"<dd>\n{tree}</dd>\n"
    return f"<dl>\n{result}</dl>\n"

def document_data(
    the_object: TypeLike,
    name: str = "",
) -> str:
    """Produce html documentation for a data descriptor."""

    results: List[str] = []

    if name:
        results.append(f"<dl><dt><strong>{name}</strong></dt>\n")
    doc = markup(getdoc(the_object))
    if doc:
        results.append(f"<dd><tt>{doc}</tt></dd>\n")
    results.append("</dl>\n")

    return "".join(results)

def docmodule(
    the_object: TypeLike,
) -> str:
    """Produce HTML documentation for a module object."""
    # circular ref
    from pydoc_fork.reporter.format_page import document

    name = the_object.__name__

    try:
        all_things = None if settings.DOCUMENT_INTERNALS else the_object.__all__
    except AttributeError:
        all_things = None
    parts = name.split(".")
    links = []
    for i in range(len(parts) - 1):
        link_url = ".".join(parts[: i + 1])
        link_text = parts[i]
        links.append(
            f'<a href="{link_url}.html"><span style="color:{inline_styles.MODULE_LINK}">{link_text}</span></a>'
        )
    linked_name = ".".join(links + parts[-1:])
    head = f"<big><big><strong>{linked_name}</strong></big></big>"
    try:
        path = inspect.getabsfile(cast(type, the_object))
        # MR : Make relative
        output_folder_path = os.path.normcase(os.path.abspath(settings.OUTPUT_FOLDER))
        path = os.path.relpath(path, output_folder_path).replace("\\", "/")
        # end MR
        # uh, oh, forgot why I wrote this
        # url = urllib.parse.quote(path)
        # MR
        file_link_text = file_link(path, path)
    except TypeError:
        file_link_text = "(built-in)"
    info = []
    # TODO: Include the rest of the meta data
    if hasattr(the_object, "__version__"):
        version = str(the_object.__version__)
        if version[:11] == "$" + "Revision: " and version[-1:] == "$":
            version = version[11:-1].strip()
        info.append(f"version {escape(version)}")
    if hasattr(the_object, "__date__"):
        info.append(escape(str(the_object.__date__)))
    if info:
        head = head + f" ({', '.join(info)})"
    document_location = getdocloc(the_object)
    if document_location is not None:
        # Was this just a bug? document_location/locals?
        # document_location = '<br><a href="%(docloc)s">Module Reference</a>' % locals()
        document_location = f'<br><a href="{document_location}">Module Reference</a>'
    else:
        document_location = ""
    result = heading(
        head,
        "#ffffff",
        "#7799ee",
        '<a href=".">index</a><br>' + file_link_text + document_location,
    )

    # this will get `import foo` but ignore `from foo import bar`
    # And bar gets no doc string love either!
    modules = inspect.getmembers(the_object, inspect.ismodule)

    for to_remove in settings.SKIP_MODULES:
        for module_info in modules:
            candidate_module, _ = module_info
            if candidate_module == to_remove:
                try:
                    modules.remove(module_info)
                except ValueError:
                    pass
    modules_by_import_from = set()
    classes, class_dict = [], {}
    for key, value in inspect.getmembers(the_object, inspect.isclass):
        _class_module = inspect.getmodule(value)
        if _class_module and _class_module is not the_object:
            if _class_module.__name__ not in settings.SKIP_MODULES:
                modules_by_import_from.add((None, _class_module))
                settings.MENTIONED_MODULES.add((_class_module, _class_module.__name__))
        # if __all__ exists, believe it.  Otherwise use old heuristic.
        if (
            # TODO put doc internals switch here
            # all_things is not None or
            (inspect.getmodule(value) or the_object)
            is the_object
        ):
            if visiblename(key, all_things, the_object):
                classes.append((key, value))
                class_dict[key] = class_dict[value] = "#" + key
    for key, value in classes:
        for base in value.__bases__:
            key, modname = base.__name__, base.__module__
            module = sys.modules.get(modname)
            if (
                modname != name
                and module
                and hasattr(module, key)
                and getattr(module, key) is base
                and key not in class_dict
            ):
                class_dict[key] = class_dict[base] = modname + ".html#" + key
    funcs, function_dict = [], {}
    for key, value in inspect.getmembers(the_object, inspect.isroutine):
        # if __all__ exists, believe it.  Otherwise use old heuristic.
        _func_module = inspect.getmodule(value)
        # why does this sometimes return no module?
        if _func_module and _func_module is not the_object:
            if _func_module.__name__ not in settings.SKIP_MODULES:
                modules_by_import_from.add((None, _func_module))
                settings.MENTIONED_MODULES.add((_func_module, _func_module.__name__))
        if (
            True
            # TODO put doc internals switch here
            # all_things is not None or # __all__ as scope limiter
            # inspect.isbuiltin(value)  # thing w/o module
            # or inspect.getmodule(value) is the_object # from foo import bar
        ) and visiblename(key, all_things, the_object):
            funcs.append((key, value))
            function_dict[key] = "#-" + key
            if inspect.isfunction(value):
                function_dict[value] = function_dict[key]
    data = []
    for key, value in inspect.getmembers(the_object, isdata):
        if inspect.getmodule(type(value)).__name__ in settings.SKIP_MODULES:
            continue
        if visiblename(key, all_things, the_object):
            data.append((key, value))

    doc = markup(getdoc(the_object), function_dict, class_dict)
    doc = doc and f"<tt>{doc}</tt>"
    result = result + f"<p>{doc}</p>\n"

    if hasattr(the_object, "__path__"):
        module_packages = []
        for _, modname, is_package in pkgutil.iter_modules(the_object.__path__):
            if modname not in settings.SKIP_MODULES:
                module_packages.append((modname, name, is_package, 0))
        module_packages.sort()
        contents_string = multicolumn(module_packages, module_package_link)
        result = result + bigsection(
            "Package Contents", "#ffffff", "#aa55cc", contents_string
        )
    elif modules:
        contents_string = multicolumn(modules, lambda t: modulelink(t[1]))
        result = result + bigsection("Modules", "#ffffff", "#aa55cc", contents_string)

    if modules_by_import_from:
        contents_string = multicolumn(
            list(modules_by_import_from), lambda t: modulelink(list(t)[1])
        )
        result = result + bigsection(
            "`from` Modules", "#ffffff", "#aa55cc", contents_string
        )

    if classes:
        class_list = [value for (key, value) in classes]
        # MR: boolean type safety
        contents_list = [format_tree(inspect.getclasstree(class_list, True), name)]
        for key, value in classes:
            contents_list.append(document(value, key, name, function_dict, class_dict))
        result = result + bigsection(
            "Classes", "#ffffff", "#ee77aa", " ".join(contents_list)
        )
    if funcs:
        contents_list = []
        for key, value in funcs:
            contents_list.append(document(value, key, name, function_dict, class_dict))
        result = result + bigsection(
            "Functions", "#ffffff", "#eeaa77", " ".join(contents_list)
        )
    if data:
        contents_list = []
        for key, value in data:
            contents_list.append(document(value, key))
        result = result + bigsection(
            "Data", "#ffffff", "#55aa55", "<br>\n".join(contents_list)
        )
    if hasattr(the_object, "__author__"):
        contents = markup(str(the_object.__author__))
        result = result + bigsection("Author", "#ffffff", "#7799ee", contents)
    if hasattr(the_object, "__credits__"):
        contents = markup(str(the_object.__credits__))
        result = result + bigsection("Credits", "#ffffff", "#7799ee", contents)

    return result

def getdocloc(the_object: TypeLike, basedir: str = STDLIB_BASEDIR) -> Optional[str]:
    """Return the location of module docs or None"""
    try:
        file = inspect.getabsfile(cast(type, the_object))
    except TypeError:
        file = "(built-in)"

    basedir = os.path.normcase(basedir)
    is_known_stdlib = the_object.__name__ in (
        "errno",
        "exceptions",
        "gc",
        "imp",
        "marshal",
        "posix",
        "signal",
        "sys",
        "_thread",
        "zipimport",
    )
    is_module = isinstance(the_object, type(os))
    is_in_pythons_folder = file.startswith(basedir) and not file.startswith(
        os.path.join(basedir, "site-packages")
    )
    # # This is nasty special case coding, how many more special cases are there?
    # is_exception =the_object.__name__ in ("xml.etree", "test.pydoc_mod")
    # # special case for etree
    # "https://docs.python.org/3/library/xml.etree.elementtree.html"

    if (
        is_module
        and (is_known_stdlib or is_in_pythons_folder)
        and settings.PREFER_DOCS_PYTHON_ORG
    ):
        if settings.PYTHONDOCS.startswith(("http://", "https://")):
            doc_loc = (
                f"{settings.PYTHONDOCS.rstrip('/')}/{the_object.__name__.lower()}.html"
            )
        else:
            doc_loc = os.path.join(
                settings.PYTHONDOCS, the_object.__name__.lower() + ".html"
            )
    else:
        doc_loc = None
    return doc_loc

def modulelink(the_object: TypeLike) -> str:
    """Make a link for a module."""
    url = f"{the_object.__name__}.html"
    internet_link = getdocloc(the_object)

    if internet_link and settings.PREFER_DOCS_PYTHON_ORG:
        url = internet_link
    # BUG: doesn't take into consideration an alternate base
    if not internet_link:
        settings.MENTIONED_MODULES.add((the_object, the_object.__name__))
    return f'<a href="{url}">{the_object.__name__}</a>'

def docother(
    the_object: TypeLike,
    name: str = "",
) -> str:
    """Produce HTML documentation for a data object."""
    lhs = name and f"<strong>{name}</strong> = " or ""
    return lhs + html_repr(the_object)

def document(the_object: TypeLike, name: str = "", *args: Any) -> str:  # Null safety
    """Generate documentation for an object.
    This also part of the public API of class

    Types of : Module, class, routine, data descriptor, "other" are supported

    Modules ignore 1st name.

    Public API doesn't call with *args
    Args are:
    name, fdict, cdict (name twice?)
    mod, funcs, classes, mdict, the_object
    """
    args = (the_object, name) + args

    # 'try' clause is to attempt to handle the possibility that inspect
    # identifies something in a way that pydoc itself has issues handling;
    # think 'super' and how it is a descriptor (which raises the exception
    # by lacking a __name__ attribute) and an instance.
    # try:
    if inspect.ismodule(the_object):
        return docmodule(the_object)
    if inspect.isclass(the_object):
        return docclass(*args)
    if inspect.isroutine(the_object):
        return docroutine(*args)
    # except AttributeError:
    #     pass  # nosec
    if inspect.isdatadescriptor(the_object):
        return document_data(the_object, name)
    return docother(the_object, name)

def index(directory: str, shadowed: Optional[Dict[str, Any]] = None) -> str:
    """Generate an HTML index for a directory of modules."""
    module_packages = []
    if shadowed is None:
        shadowed = {}
    for _, name, is_package in pkgutil.iter_modules([directory]):
        if any((0xD800 <= ord(ch) <= 0xDFFF) for ch in name):
            # ignore a module if its name contains a surrogate character
            continue
        module_packages.append((name, "", is_package, name in shadowed))
        shadowed[name] = 1

    module_packages.sort()
    contents = multicolumn(module_packages, module_package_link)
    return bigsection(directory, "#ffffff", "#ee77aa", contents)

def page(title: str, contents: str) -> str:
    """Format an HTML page.

    This is part of the public API
    """
    template = JINJA_ENV.get_template("page.jinja2")
    result = template.render(title=title, contents=contents)
    return result

def render(title: str, the_object: TypeLike, name: str) -> str:
    """Compose two functions"""
    return page(title, document(the_object, name))