pdoc 14.1.0__tar.gz → 14.2.0__tar.gz

{pdoc-14.1.0 → pdoc-14.2.0}/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 <!-- ✨ You do not need to add a pull request reference or an author, this will be added automatically by CI. ✨ -->
 
+## 2023-12-13: pdoc 14.2.0
+
+ - pdoc now documents PyO3 or pybind11 submodules that are not picked up by Python's builtin pkgutil module.
+   ([#633](https://github.com/mitmproxy/pdoc/issues/633), @mhils)
+ - pdoc now supports Python 3.12's `type` statements and has improved `TypeAlias` rendering.
+   ([#651](https://github.com/mitmproxy/pdoc/pull/651), @mhils)
+ - Imports in a TYPE_CHECKING section that reference members defined in another module's TYPE_CHECKING section now work
+   correctly.
+   ([#649](https://github.com/mitmproxy/pdoc/pull/649), @mhils)
+ - Add support for `code-block` ReST directives
+   ([#624](https://github.com/mitmproxy/pdoc/pull/624), @JCGoran)
+ - If a variable's value meets certain entropy criteria and matches an environment variable value,
+   pdoc will now emit a warning and display the variable's name as a placeholder instead.
+   This heuristic is meant to prevent accidental leakage of environment secrets and can be disabled by setting
+   `PDOC_DISPLAY_ENV_VARS=1`.
+   ([#622](https://github.com/mitmproxy/pdoc/pull/622), @mhils)
 
 ## 2023-09-10: pdoc 14.1.0
 

{pdoc-14.1.0/pdoc.egg-info → pdoc-14.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pdoc
-Version: 14.1.0
+Version: 14.2.0
 Summary: API Documentation for Python Projects
 Author-email: Maximilian Hils <pdoc@maximilianhils.com>
 License: Unlicense

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/__init__.py

@@ -462,7 +462,7 @@ You can find an example in [`examples/library-usage`](https://github.com/mitmpro
 from __future__ import annotations
 
 __docformat__ = "markdown"  # explicitly disable rST processing in the examples above.
-__version__ = "14.1.0"  # this is read from setup.py
+__version__ = "14.2.0"  # this is read from setup.py
 
 from pathlib import Path
 from typing import overload

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/__main__.py

@@ -112,7 +112,7 @@ renderopts.add_argument(
     "--search",
     action=BooleanOptionalAction,
     default=True,
-    help="Enable search functionality.",
+    help="Enable search functionality if multiple modules are documented.",
 )
 renderopts.add_argument(
     "--show-source",

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/_compat.py

@@ -16,6 +16,24 @@ else:  # pragma: no cover
     def ast_unparse(t):  # type: ignore
         return _unparse(t).strip("\t\n \"'")
 
+if sys.version_info >= (3, 12):
+    from ast import TypeAlias as ast_TypeAlias
+else:  # pragma: no cover
+    class ast_TypeAlias:
+        pass
+
+if sys.version_info >= (3, 12):
+    from typing import TypeAliasType
+else:  # pragma: no cover
+    class TypeAliasType:
+        """Placeholder class for TypeAliasType"""
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:  # pragma: no cover
+    class TypeAlias:
+        pass
+
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 else:  # pragma: no cover
@@ -108,6 +126,9 @@ else:  # pragma: no cover
 __all__ = [
     "cache",
     "ast_unparse",
+    "ast_TypeAlias",
+    "TypeAliasType",
+    "TypeAlias",
     "GenericAlias",
     "UnionType",
     "removesuffix",

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/doc.py

@@ -28,7 +28,6 @@ from functools import wraps
 import inspect
 import os
 from pathlib import Path
-import pkgutil
 import re
 import sys
 import textwrap
@@ -45,15 +44,16 @@ import warnings
 from pdoc import doc_ast
 from pdoc import doc_pyi
 from pdoc import extract
+from pdoc._compat import TypeAlias
+from pdoc._compat import TypeAliasType
+from pdoc._compat import cache
+from pdoc._compat import formatannotation
 from pdoc.doc_types import GenericAlias
 from pdoc.doc_types import NonUserDefinedCallables
 from pdoc.doc_types import empty
 from pdoc.doc_types import resolve_annotations
 from pdoc.doc_types import safe_eval_type
 
-from ._compat import cache
-from ._compat import formatannotation
-
 
 def _include_fullname_in_traceback(f):
     """
@@ -454,9 +454,6 @@ class Module(Namespace[types.ModuleType]):
     @cached_property
     def submodules(self) -> list[Module]:
         """A list of all (direct) submodules."""
-        if not self.is_package:
-            return []
-
         include: Callable[[str], bool]
         mod_all = _safe_getattr(self.obj, "__all__", False)
         if mod_all is not False:
@@ -471,9 +468,8 @@ class Module(Namespace[types.ModuleType]):
                 # (think of OS-specific modules, e.g. _linux.py failing to import on Windows).
                 return not name.startswith("_")
 
-        submodules = []
-        for mod in pkgutil.iter_modules(self.obj.__path__, f"{self.fullname}."):
-            _, _, mod_name = mod.name.rpartition(".")
+        submodules: list[Module] = []
+        for mod_name, mod in extract.iter_modules2(self.obj).items():
             if not include(mod_name):
                 continue
             try:
@@ -1006,7 +1002,9 @@ class Function(Doc[types.FunctionType]):
                 )
             )
         for p in sig.parameters.values():
-            p._annotation = safe_eval_type(p.annotation, globalns, localns, mod, self.fullname)  # type: ignore
+            p._annotation = safe_eval_type(  # type: ignore
+                p.annotation, globalns, localns, mod, self.fullname
+            )
         return sig
 
     @cached_property
@@ -1092,6 +1090,11 @@ class Variable(Doc[None]):
         else:
             return False
 
+    @cached_property
+    def is_type_alias_type(self) -> bool:
+        """`True` if the variable is a `typing.TypeAliasType`, `False` otherwise."""
+        return isinstance(self.default_value, TypeAliasType)
+
     @cached_property
     def is_enum_member(self) -> bool:
         """`True` if the variable is an enum member, `False` otherwise."""
@@ -1105,6 +1108,27 @@ class Variable(Doc[None]):
         """The variable's default value as a pretty-printed str."""
         if self.default_value is empty:
             return ""
+        if isinstance(self.default_value, TypeAliasType):
+            return formatannotation(self.default_value.__value__)
+        elif self.annotation == TypeAlias:
+            return formatannotation(self.default_value)
+
+        # This is not perfect, but a solid attempt at preventing accidental leakage of secrets.
+        # If you have input on how to improve the heuristic, please send a pull request!
+        value_taken_from_env_var = (
+            isinstance(self.default_value, str)
+            and len(self.default_value) >= 8
+            and self.default_value in _environ_lookup()
+        )
+        if value_taken_from_env_var and not os.environ.get("PDOC_DISPLAY_ENV_VARS", ""):
+            env_var = "$" + _environ_lookup()[self.default_value]
+            warnings.warn(
+                f"The default value of {self.fullname} matches the {env_var} environment variable. "
+                f"To prevent accidental leakage of secrets, the default value is not displayed. "
+                f"Disable this behavior by setting PDOC_DISPLAY_ENV_VARS=1 as an environment variable.",
+                RuntimeWarning,
+            )
+            return env_var
 
         try:
             pretty = repr(self.default_value)
@@ -1124,6 +1148,14 @@ class Variable(Doc[None]):
             return ""
 
 
+@cache
+def _environ_lookup():
+    """
+    A reverse lookup of os.environ. This is a cached function so that it is evaluated lazily.
+    """
+    return {value: key for key, value in os.environ.items()}
+
+
 class _PrettySignature(inspect.Signature):
     """
     A subclass of `inspect.Signature` that pads __str__ over several lines

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/doc_ast.py

@@ -21,6 +21,7 @@ import warnings
 
 import pdoc
 
+from ._compat import ast_TypeAlias
 from ._compat import ast_unparse
 from ._compat import cache
 
@@ -115,7 +116,11 @@ def _walk_tree(
     func_docstrings = {}
     annotations = {}
     for a, b in _pairwise_longest(_nodes(tree)):
-        if isinstance(a, ast.AnnAssign) and isinstance(a.target, ast.Name) and a.simple:
+        if isinstance(a, ast_TypeAlias):
+            name = a.name.id
+        elif (
+            isinstance(a, ast.AnnAssign) and isinstance(a.target, ast.Name) and a.simple
+        ):
             name = a.target.id
             annotations[name] = unparse(a.annotation)
         elif (
@@ -183,6 +188,8 @@ def sort_by_source(
             name = a.target.id
         elif isinstance(a, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
             name = a.name
+        elif isinstance(a, ast_TypeAlias):
+            name = a.name.id
         else:
             continue
 

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/doc_types.py

@@ -124,9 +124,9 @@ def safe_eval_type(
 
     # Simple _eval_type has failed. We now execute all TYPE_CHECKING sections in the module and try again.
     if module:
+        assert module.__dict__ is globalns
         try:
-            code = compile(type_checking_sections(module), "<string>", "exec")
-            eval(code, globalns, globalns)
+            _eval_type_checking_sections(module, set())
         except Exception as e:
             warnings.warn(
                 f"Failed to run TYPE_CHECKING code while parsing {t} type annotation for {fullname}: {e}"
@@ -148,7 +148,34 @@ def safe_eval_type(
             f"Error parsing type annotation {t} for {fullname}. Import of {mod} failed: {err}"
         )
         return t
-    return safe_eval_type(t, {mod: val, **globalns}, localns, module, fullname)
+    else:
+        globalns[mod] = val
+    return safe_eval_type(t, globalns, localns, module, fullname)
+
+
+def _eval_type_checking_sections(module: types.ModuleType, seen: set) -> None:
+    """
+    Evaluate all TYPE_CHECKING sections within a module.
+
+    The added complication here is that TYPE_CHECKING sections may import members from other modules' TYPE_CHECKING
+    sections. So we try to recursively execute those other modules' TYPE_CHECKING sections as well.
+    See https://github.com/mitmproxy/pdoc/issues/648 for a real world example.
+    """
+    if module.__name__ in seen:
+        raise RecursionError(f"Recursion error when importing {module.__name__}.")
+    seen.add(module.__name__)
+
+    code = compile(type_checking_sections(module), "<string>", "exec")
+    while True:
+        try:
+            eval(code, module.__dict__, module.__dict__)
+        except ImportError as e:
+            if e.name is not None and (mod := sys.modules.get(e.name, None)):
+                _eval_type_checking_sections(mod, seen)
+            else:
+                raise
+        else:
+            break
 
 
 def _eval_type(t, globalns, localns, recursive_guard=frozenset()):

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/docstrings.py

@@ -393,7 +393,9 @@ def _rst_admonitions(contents: str, source_file: Path | None) -> str:
                 f"{indent(contents, ind)}\n"
                 f"{ind}</div>\n"
             )
-        elif type == "versionadded":
+        if type == "code-block":
+            return f"{ind}```{val}\n{contents}\n```\n"
+        if type == "versionadded":
             text = f"New in version {val}"
         elif type == "versionchanged":
             text = f"Changed in version {val}"
@@ -409,7 +411,7 @@ def _rst_admonitions(contents: str, source_file: Path | None) -> str:
 
         return text
 
-    admonition = "note|warning|danger|versionadded|versionchanged|deprecated|seealso|math|include"
+    admonition = "note|warning|danger|versionadded|versionchanged|deprecated|seealso|math|include|code-block"
     return re.sub(
         rf"""
             ^(?P<indent>[ ]*)\.\.[ ]+(?P<type>{admonition})::(?P<val>.*)

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/extract.py

@@ -204,9 +204,7 @@ def mock_some_common_side_effects():
         "os.startfile", new=_noop, create=True
     ), patch("sys.stdout", new=io.StringIO()), patch(
         "sys.stderr", new=io.StringIO()
-    ), patch(
-        "sys.stdin", new=io.StringIO()
-    ):
+    ), patch("sys.stdin", new=io.StringIO()):
         yield
 
 
@@ -229,22 +227,71 @@ but we don't want to catch a user's KeyboardInterrupt.
 """
 
 
+def iter_modules2(module: types.ModuleType) -> dict[str, pkgutil.ModuleInfo]:
+    """
+    Returns all direct child modules of a given module.
+    This function is similar to `pkgutil.iter_modules`, but
+
+      1. Respects a package's `__all__` attribute if specified.
+         If `__all__` is defined, submodules not listed in `__all__` are excluded.
+      2. It will try to detect submodules that are not findable with iter_modules,
+         but are present in the module object.
+    """
+    mod_all = getattr(module, "__all__", None)
+
+    submodules = {}
+
+    for submodule in pkgutil.iter_modules(
+        getattr(module, "__path__", []), f"{module.__name__}."
+    ):
+        name = submodule.name.rpartition(".")[2]
+        if mod_all is None or name in mod_all:
+            submodules[name] = submodule
+
+    # 2023-12: PyO3 and pybind11 submodules are not detected by pkgutil
+    # This is a hacky workaround to register them.
+    members = dir(module) if mod_all is None else mod_all
+    for name in members:
+        if name in submodules or name == "__main__":
+            continue
+        member = getattr(module, name, None)
+        is_wild_child_module = (
+            isinstance(member, types.ModuleType)
+            # the name is either just "bar", but can also be "foo.bar",
+            # see https://github.com/PyO3/pyo3/issues/759#issuecomment-1811992321
+            and (
+                member.__name__ == f"{module.__name__}.{name}"
+                or (
+                    member.__name__ == name
+                    and sys.modules.get(member.__name__, None) is not member
+                )
+            )
+        )
+        if is_wild_child_module:
+            # fixup the module name so that the rest of pdoc does not break
+            assert member
+            member.__name__ = f"{module.__name__}.{name}"
+            sys.modules[f"{module.__name__}.{name}"] = member
+            submodules[name] = pkgutil.ModuleInfo(
+                None,  # type: ignore
+                name=f"{module.__name__}.{name}",
+                ispkg=True,
+            )
+
+    submodules.pop("__main__", None)  # https://github.com/mitmproxy/pdoc/issues/438
+
+    return submodules
+
+
 def walk_packages2(
     modules: Iterable[pkgutil.ModuleInfo],
 ) -> Iterator[pkgutil.ModuleInfo]:
     """
     For a given list of modules, recursively yield their names and all their submodules' names.
 
-    This function is similar to `pkgutil.walk_packages`, but respects a package's `__all__` attribute if specified.
-    If `__all__` is defined, submodules not listed in `__all__` are excluded.
+    This function is similar to `pkgutil.walk_packages`, but based on `iter_modules2`.
     """
-
-    # noinspection PyDefaultArgument
-    def seen(p, m={}):  # pragma: no cover
-        if p in m:
-            return True
-        m[p] = True
-
+    # the original walk_packages implementation has a recursion check for path, but that does not seem to be needed?
     for mod in modules:
         yield mod
 
@@ -255,19 +302,8 @@ def walk_packages2(
                 warnings.warn(f"Error loading {mod.name}:\n{traceback.format_exc()}")
                 continue
 
-            mod_all = getattr(module, "__all__", None)
-            # don't traverse path items we've seen before
-            path = [p for p in (getattr(module, "__path__", None) or []) if not seen(p)]
-
-            submodules = []
-            for submodule in pkgutil.iter_modules(path, f"{mod.name}."):
-                name = submodule.name.rpartition(".")[2]
-                if name == "__main__":
-                    continue  # https://github.com/mitmproxy/pdoc/issues/438
-                if mod_all is None or name in mod_all:
-                    submodules.append(submodule)
-
-            yield from walk_packages2(submodules)
+            submodules = iter_modules2(module)
+            yield from walk_packages2(submodules.values())
 
 
 def module_mtime(modulename: str) -> float | None:

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/search.py

@@ -5,6 +5,11 @@ and works without any third-party services in a privacy-preserving way. When a u
 search box for the first time, pdoc will fetch the search index (`search.js`) and use that to
 answer all upcoming queries.
 
+##### Single-Page Documentation
+
+If pdoc is documenting a single module only, search functionality will be disabled.
+The browser's built-in search functionality will provide a better user experience in these cases.
+
 ##### Search Coverage
 
 The search functionality covers all documented elements and their docstrings.

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc/templates/default/module.html.jinja2

@@ -177,6 +177,7 @@ See https://pdoc.dev/docs/pdoc/render_helpers.html#DefaultMacroExtension for an
     {% endif %}
 {% enddefaultmacro %}
 {% defaultmacro variable(var) -%}
+    {%- if var.is_type_alias_type %}<span class="def">type</span> {% endif -%}
     <span class="name">{{ var.name }}</span>{{ annotation(var) }}{{ default_value(var) }}
 {% enddefaultmacro %}
 {% defaultmacro submodule(mod) -%}

{pdoc-14.1.0 → pdoc-14.2.0/pdoc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pdoc
-Version: 14.1.0
+Version: 14.2.0
 Summary: API Documentation for Python Projects
 Author-email: Maximilian Hils <pdoc@maximilianhils.com>
 License: Unlicense

{pdoc-14.1.0 → pdoc-14.2.0}/pdoc.egg-info/requires.txt

@@ -8,7 +8,6 @@ astunparse
 [dev]
 tox
 ruff
-black
 mypy
 types-pygments
 pytest
@@ -16,3 +15,4 @@ pytest-cov
 pytest-timeout
 hypothesis
 pygments>=2.14.0
+pdoc-pyo3-sample-library==1.0.11

{pdoc-14.1.0 → pdoc-14.2.0}/pyproject.toml

@@ -44,7 +44,6 @@ pdoc = "pdoc.__main__:cli"
 dev = [
     "tox",
     "ruff",
-    "black",
     "mypy",
     "types-pygments",
     "pytest",
@@ -52,6 +51,7 @@ dev = [
     "pytest-timeout",
     "hypothesis",
     "pygments >= 2.14.0",
+    "pdoc-pyo3-sample-library==1.0.11",
 ]
 
 [build-system]
@@ -89,9 +89,6 @@ markers = [
     "slow: marks tests as slow.",
 ]
 
-[tool.black]
-extend-exclude = "test/testdata/demo.py"
-
 [[tool.mypy.overrides]]
 module = "pytest.*"
 ignore_missing_imports = true
@@ -101,8 +98,9 @@ module = "demopackage2"
 ignore_missing_imports = true
 
 [tool.ruff]
-line-length = 140
+extend-exclude = ["test/testdata/demo.py"]
 select = ["E", "F", "I"]
+ignore = ["E501"]
 
 [tool.ruff.isort]
 force-single-line = true

{pdoc-14.1.0 → pdoc-14.2.0}/test/test_doc.py

@@ -11,6 +11,7 @@ from pdoc import extract
 from pdoc.doc import Class
 from pdoc.doc import Module
 from pdoc.doc import Variable
+from pdoc.doc import _environ_lookup
 from pdoc.doc_types import empty
 
 here = Path(__file__).parent
@@ -143,3 +144,34 @@ def test_raising_submodules():
             assert m.submodules
     finally:
         f.write_bytes(b"# syntax error will be inserted by test here\n")
+
+
+def test_default_value_masks_env_vars(monkeypatch):
+    monkeypatch.setenv("SUPER_SECRET_TOKEN", "correct horse battery staple")
+    monkeypatch.setenv("VERSION_NUMBER", "42.0.1")
+    _environ_lookup.cache_clear()
+    try:
+        v1 = Variable(
+            "module",
+            "var",
+            taken_from=("module", "var"),
+            docstring="",
+            annotation=empty,
+            default_value="correct horse battery staple",
+        )
+        with pytest.warns(
+            match=r"The default value of module.var matches the \$SUPER_SECRET_TOKEN environment variable."
+        ):
+            assert v1.default_value_str == "$SUPER_SECRET_TOKEN"
+
+        v2 = Variable(
+            "module",
+            "version",
+            taken_from=("module", "version"),
+            docstring="",
+            annotation=empty,
+            default_value="42.0.1",
+        )
+        assert v2.default_value_str == "'42.0.1'"
+    finally:
+        _environ_lookup.cache_clear()

{pdoc-14.1.0 → pdoc-14.2.0}/test/test_doc_types.py

@@ -12,8 +12,9 @@ from pdoc.doc_types import safe_eval_type
     "typestr", ["totally_unknown_module", "!!!!", "html.unknown_attr"]
 )
 def test_eval_fail(typestr):
+    a = types.ModuleType("a")
     with pytest.warns(UserWarning, match="Error parsing type annotation"):
-        assert safe_eval_type(typestr, {}, None, types.ModuleType("a"), "a") == typestr
+        assert safe_eval_type(typestr, a.__dict__, None, a, "a") == typestr
 
 
 def test_eval_fail2(monkeypatch):
@@ -22,8 +23,9 @@ def test_eval_fail2(monkeypatch):
         "get_source",
         lambda _: "import typing\nif typing.TYPE_CHECKING:\n\traise RuntimeError()",
     )
+    a = types.ModuleType("a")
     with pytest.warns(UserWarning, match="Failed to run TYPE_CHECKING code"):
-        assert safe_eval_type("xyz", {}, None, types.ModuleType("a"), "a") == "xyz"
+        assert safe_eval_type("xyz", a.__dict__, None, a, "a") == "xyz"
 
 
 def test_eval_fail3(monkeypatch):
@@ -32,16 +34,24 @@ def test_eval_fail3(monkeypatch):
         "get_source",
         lambda _: "import typing\nif typing.TYPE_CHECKING:\n\tFooFn = typing.Callable[[],int]",
     )
+    a = types.ModuleType("a")
+    a.__dict__["typing"] = typing
     with pytest.warns(
         UserWarning,
         match="Error parsing type annotation .+ after evaluating TYPE_CHECKING blocks",
     ):
-        assert (
-            safe_eval_type(
-                "FooFn[int]", {"typing": typing}, None, types.ModuleType("a"), "a"
-            )
-            == "FooFn[int]"
-        )
+        assert safe_eval_type("FooFn[int]", a.__dict__, None, a, "a") == "FooFn[int]"
+
+
+def test_eval_fail_import_nonexistent(monkeypatch):
+    monkeypatch.setattr(
+        doc_ast,
+        "get_source",
+        lambda _: "import typing\nif typing.TYPE_CHECKING:\n\timport nonexistent_module",
+    )
+    a = types.ModuleType("a")
+    with pytest.warns(UserWarning, match="No module named 'nonexistent_module'"):
+        assert safe_eval_type("xyz", a.__dict__, None, a, "a") == "xyz"
 
 
 def test_eval_union_types_on_old_python(monkeypatch):
@@ -53,3 +63,21 @@ def test_eval_union_types_on_old_python(monkeypatch):
     ):
         # str never implements `|`, so we can use that to trigger the error on newer versions.
         safe_eval_type('"foo" | "bar"', {}, None, None, "example")
+
+
+def test_recurse(monkeypatch):
+    def get_source(mod):
+        if mod == a:
+            return "import typing\nif typing.TYPE_CHECKING:\n\tfrom b import Foo"
+        else:
+            return "import typing\nif typing.TYPE_CHECKING:\n\tfrom a import Foo"
+
+    a = types.ModuleType("a")
+    b = types.ModuleType("b")
+
+    monkeypatch.setattr(doc_ast, "get_source", get_source)
+    monkeypatch.setitem(sys.modules, "a", a)
+    monkeypatch.setitem(sys.modules, "b", b)
+
+    with pytest.warns(UserWarning, match="Recursion error when importing a"):
+        assert safe_eval_type("xyz", a.__dict__, None, a, "a") == "xyz"

{pdoc-14.1.0 → pdoc-14.2.0}/test/test_extract.py

@@ -60,6 +60,14 @@ def test_walk_specs():
         "test.mod_with_main.__main__",
     ]
 
+    assert walk_specs(["pdoc_pyo3_sample_library"]) == [
+        "pdoc_pyo3_sample_library",
+        "pdoc_pyo3_sample_library.submodule",
+        "pdoc_pyo3_sample_library.submodule.subsubmodule",
+        "pdoc_pyo3_sample_library.explicit_submodule",
+        "pdoc_pyo3_sample_library.correct_name_submodule",
+    ]
+
 
 def test_parse_spec(monkeypatch):
     p = sys.path

{pdoc-14.1.0 → pdoc-14.2.0}/test/test_snapshot.py

@@ -29,14 +29,14 @@ class Snapshot:
     def __init__(
         self,
         id: str,
-        filenames: list[str] | None = None,
+        specs: list[str] | None = None,
         render_options: dict | None = None,
         with_output_directory: bool = False,
         min_version: tuple[int, int] = (3, 7),
         warnings: list[str] | None = None,
     ):
         self.id = id
-        self.specs = filenames or [f"{id}.py"]
+        self.specs = specs or [f"{id}.py"]
         self.render_options = render_options or {}
         self.with_output_directory = with_output_directory
         self.min_version = min_version
@@ -145,6 +145,7 @@ snapshots = [
         min_version=(3, 12),
     ),
     Snapshot("math_demo", render_options={"math": True}),
+    Snapshot("math_misc", render_options={"math": True}),
     Snapshot("mermaid_demo", render_options={"mermaid": True}, min_version=(3, 9)),
     Snapshot(
         "render_options",
@@ -159,8 +160,9 @@ snapshots = [
         },
         with_output_directory=True,
     ),
+    Snapshot("pyo3_sample_library", specs=["pdoc_pyo3_sample_library"]),
     Snapshot("top_level_reimports", ["top_level_reimports"]),
-    Snapshot("type_checking_imports"),
+    Snapshot("type_checking_imports", ["type_checking_imports.main"]),
     Snapshot("type_stub", min_version=(3, 10)),
     Snapshot(
         "visibility",