sphinx-codeautolink 0.18.1__tar.gz → 0.20.0__tar.gz

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sphinx-codeautolink
-Version: 0.18.1
+Version: 0.20.0
 Summary: Automatic links from code examples to reference documentation.
 Author-email: Felix Hildén <felix.hilden@gmail.com>
 Maintainer-email: Felix Hildén <felix.hilden@gmail.com>
@@ -15,15 +15,15 @@ Classifier: Framework :: Sphinx
 Classifier: Framework :: Sphinx :: Extension
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Documentation
 Classifier: Topic :: Documentation :: Sphinx
 Classifier: Topic :: Software Development :: Documentation
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: sphinx>=3.2.0

sphinx_codeautolink-0.20.0/docs/requirements.txt

@@ -0,0 +1,6 @@
+# Manually pin Sphinx + docs requirements
+sphinx==9.2.0
+sphinx-rtd-theme==3.1.0
+docutils==0.21.2
+matplotlib==3.11.2
+ipython==9.18.1

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/docs/src/about.rst

@@ -10,7 +10,7 @@ That information is fed to the name resolver, which attempts to match a series
 of attributes and calls to the concrete type in question by following
 type hints and other information accessible via imports of the library.
 If a match is found, a link to the correct reference documentation entry
-is injected after the ordinary Sphinx build is finished.
+is injected into the HTML of the page as it is written.
 
 .. _caveats:
 
@@ -44,6 +44,9 @@ Caveats
     change after the definition and impact the function.
     Encountering this should be unlikely, because it only occurs in practice
     when a variable shadows or overwrites an imported module or its part.
+  - Type parameters of generic functions, classes and type aliases
+    (``def f[T](arg: T)``) do not shadow imported names, so an imported ``T``
+    would be linked inside the definition.
 
   These cases are subject to change when the library matures. For more details
   on the expected failures, see our `test suite on GitHub <https://github.com

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/docs/src/reference.rst

@@ -55,6 +55,15 @@ Configuration
    Useful when objects are imported and documented somewhere else than their
    original location as advertised by ``__module__``.
 
+.. confval:: codeautolink_disable_link_titles
+
+   Type: ``bool``. Don't add a ``title`` attribute, shown as a tooltip on
+   hover, to code links. By default the title contains the resolved location
+   of the linked object, but only when it differs from the code that is being
+   linked: hovering over ``instance.method()`` shows ``module.Class.method``,
+   while hovering over ``module.Class`` adds no tooltip.
+   Defaults to :code:`False`.
+
 .. confval:: codeautolink_warn_on_missing_inventory
 
    Type: ``bool``. Warn when an object cannot be found in

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/docs/src/release_notes.rst

@@ -8,6 +8,33 @@ These release notes are based on
 sphinx-codeautolink adheres to
 `Semantic Versioning <https://semver.org>`_.
 
+0.20.0 (2026-11-08)
+-------------------
+- Inject links while each page is written, instead of rewriting the HTML
+  files after the build. This makes builds faster, and fixes links missing
+  from pages that Sphinx rewrites without their source changing, such as the
+  parent of a renamed toctree entry (:issue:`205`)
+- Don't link names assigned from a call returning a union such as
+  ``Foo | Bar`` to ``typing.Union`` on Python 3.14
+- Support Python 3.15 officially, and remove support for 3.10 (:issue:`206`)
+- Link assignments from builtins (:issue:`207`)
+- Avoid crashing in dict comprehensions with ``**`` unpacking (:issue:`208`)
+- Link names in bounds and defaults of type parameters (:issue:`209`)
+- Track ``type`` alias statements (:issue:`210`)
+- Link comprehension targets from the iterable (:issue:`211`)
+
+0.19.0 (2026-07-29)
+-------------------
+- Only add a hover title to links when the resolved location of the object
+  differs from the linked code, and add
+  :confval:`codeautolink_disable_link_titles`
+  to disable the titles altogether (:issue:`200`)
+- Fix "Could not match transformation" warnings for assignments to
+  attributes such as ``thing.attr = 1`` (:issue:`201`)
+- Resolve ``typing.Self`` return annotations, respecting inheritance so a
+  ``Self``-returning method accessed through a subclass or mixin resolves to
+  the accessing class rather than the class it's defined on (:issue:`147`)
+
 0.18.1 (2026-04-30)
 -------------------
 - Recognize aliased ``TYPE_CHECKING`` imports such as

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/pyproject.toml

@@ -9,7 +9,7 @@ readme = "readme_pypi.rst"
 license-files = ["LICENSE"]
 dynamic = ["version"]
 
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
     "sphinx>=3.2.0",
     "beautifulsoup4>=4.8.1",
@@ -26,11 +26,11 @@ classifiers = [
     "Framework :: Sphinx :: Extension",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Documentation",
     "Topic :: Documentation :: Sphinx",
     "Topic :: Software Development :: Documentation",
@@ -72,6 +72,7 @@ ignore = [
 extend-ignore = [
     "ARG001", # unused args needed in interfaces
     "ARG002", # unused args needed in interfaces
+    "CPY001", # no copyright notices needed
     "D107", # docstring missing is fine
     "D203", # recommended by ruff format
     "D212", # docstring format clash
@@ -80,6 +81,7 @@ extend-ignore = [
     "ISC001", # recommended by ruff format
     "PLR0913", # many arguments is fine
     "PLR0915", # many statements is fine
+    "PLR0917", # many arguments is fine
 ]
 extend-unsafe-fixes = ["F401"]
 isort.split-on-trailing-comma = false

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink/__init__.py

@@ -8,7 +8,7 @@ from .extension import SphinxCodeAutoLink, backref, directive
 from .extension.block import clean_ipython, clean_pycon
 from .extension.translation import MESSAGE_CATALOG_NAME
 
-__version__ = "0.18.1"
+__version__ = "0.20.0"
 
 
 def setup(app: Sphinx):
@@ -34,6 +34,9 @@ def setup(app: Sphinx):
     app.add_config_value(
         "codeautolink_inventory_map", default={}, rebuild="html", types=[dict]
     )
+    app.add_config_value(
+        "codeautolink_disable_link_titles", default=False, rebuild="html", types=[bool]
+    )
     app.add_config_value(
         "codeautolink_warn_on_missing_inventory",
         default=False,
@@ -71,7 +74,8 @@ def setup(app: Sphinx):
     app.connect("env-purge-doc", state.purge_doc_from_environment)
     app.connect("env-updated", state.create_references)
     app.connect("doctree-resolved", state.generate_backref_tables)
-    app.connect("build-finished", state.apply_links)
+    app.connect("html-page-context", state.apply_links)
+    app.connect("build-finished", state.write_cache)
 
     app.add_node(
         backref.DetailsNode, html=(backref.visit_details, backref.depart_details)

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink/extension/__init__.py

@@ -78,9 +78,9 @@ class SphinxCodeAutoLink:
         self.warn_no_backreference = None
         self.warn_default_parse_fail = None
         self.highlight_lang = None
+        self.disable_link_titles = None
 
         # Populated once
-        self.outdated_docs: set[str] = set()
         self.inventory = {}
         self.code_refs: dict[str, list[CodeExample]] = {}
 
@@ -97,7 +97,6 @@ class SphinxCodeAutoLink:
         self.cache = DataCache(app.doctreedir, app.srcdir)
         self.cache.read()
         app.env.sphinx_codeautolink_transforms = self.cache.transforms
-        self.outdated_docs = {str(Path(d)) for d in app.builder.get_outdated_docs()}
         self.custom_blocks = app.config.codeautolink_custom_blocks
         for k, v in self.custom_blocks.items():
             if isinstance(v, str):
@@ -112,6 +111,7 @@ class SphinxCodeAutoLink:
             app.config.codeautolink_warn_on_default_parse_fail
         )
         self.highlight_lang = app.config.highlight_language
+        self.disable_link_titles = app.config.codeautolink_disable_link_titles
 
         # Append static resources path so references in setup() are valid
         app.config.html_static_path.append(
@@ -279,23 +279,30 @@ class SphinxCodeAutoLink:
         return None
 
     @print_exceptions()
-    def apply_links(self, app, exception) -> None:
-        """Apply links to HTML output and write refs file."""
-        if self.do_nothing or exception is not None:
+    def apply_links(self, app, pagename, templatename, context, doctree) -> None:
+        """Apply links to the HTML body of a page before it is written."""
+        if self.do_nothing:
             return
 
-        for doc, transforms in self.cache.transforms.items():
-            if not transforms or str(Path(doc)) not in self.outdated_docs:
-                continue
-            link_html(
-                doc,
-                app.outdir,
-                transforms,
-                self.inventory,
-                self.custom_blocks,
-                self.search_css_classes,
-                builder_name=app.builder.name,
-            )
+        transforms = self.cache.transforms.get(str(Path(pagename)))
+        if not transforms:
+            return
+        context["body"] = link_html(
+            pagename,
+            context["body"],
+            transforms,
+            self.inventory,
+            self.custom_blocks,
+            self.search_css_classes,
+            builder_name=app.builder.name,
+            disable_link_titles=self.disable_link_titles,
+        )
+
+    @print_exceptions()
+    def write_cache(self, app, exception) -> None:
+        """Write refs file."""
+        if self.do_nothing or exception is not None:
+            return
 
         self.cache.write()
 

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink/extension/block.py

@@ -369,23 +369,32 @@ class CodeBlockAnalyser(nodes.SparseNodeVisitor):
         )
 
 
+def format_title(location: str, text: str) -> str:
+    """Format the title attribute of a link, empty if it wouldn't add information."""
+    code = re.sub(r"\s+", "", BeautifulSoup(text, "html.parser").get_text())
+    if code == location:
+        return ""
+    return f' title="{location}"'
+
+
 def link_html(
     document: str,
-    out_dir: str,
+    html: str,
     transforms: list[SourceTransform],
     inventory: dict,
     custom_blocks: dict,
     search_css_classes: list,
     builder_name: str = "html",
-) -> None:
-    """Inject links to code blocks on disk."""
+    *,
+    disable_link_titles: bool,
+) -> str:
+    """Inject links to code blocks in the HTML of a document."""
     if builder_name == "dirhtml" and Path(document).name != "index":
-        html_file = Path(out_dir) / document / "index.html"
+        html_file = Path(document) / "index.html"
     else:
-        html_file = Path(out_dir) / (document + ".html")
+        html_file = Path(document + ".html")
 
-    text = html_file.read_text("utf-8")
-    soup = BeautifulSoup(text, "html.parser")
+    soup = BeautifulSoup(html, "html.parser")
 
     block_types = BUILTIN_BLOCKS.keys() | custom_blocks.keys()
     classes = [f"highlight-{t}" for t in block_types] + ["doctest"]
@@ -398,11 +407,9 @@ def link_html(
     blocks = sorted(unique_blocks, key=lambda b: b.sourceline)
     inners = [block.select("div > pre")[0] for block in blocks]
 
-    up_lvls = len(html_file.relative_to(out_dir).parents) - 1
+    up_lvls = len(html_file.parents) - 1
     local_prefix = "../" * up_lvls
-    link_pattern = (
-        '<a href="{link}" title="{title}" class="sphinx-codeautolink-a">{text}</a>'
-    )
+    link_pattern = '<a href="{link}"{title} class="sphinx-codeautolink-a">{text}</a>'
 
     for trans in transforms:
         for ix in range(len(inners)):
@@ -447,15 +454,19 @@ def link_html(
             location = inventory[name.resolved_location]
             if not any(location.startswith(s) for s in ("http://", "https://")):
                 location = local_prefix + location
-            link = link_pattern.format(
-                link=location, title=name.resolved_location, text=selection[start:end]
+            text = selection[start:end]
+            title = (
+                ""
+                if disable_link_titles
+                else format_title(name.resolved_location, text)
             )
+            link = link_pattern.format(link=location, title=title, text=text)
             transformed = selection[:start] + link + selection[end:]
             lines[begin_line : end_line + 1] = transformed.split("\n")
 
         inner.replace_with(BeautifulSoup("\n".join(lines), "html.parser"))
 
-    html_file.write_text(str(soup), "utf-8")
+    return str(soup)
 
 
 # ---------------------------------------------------------------

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink/extension/resolve.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast
+import builtins
 import inspect
 from collections import abc
 from collections.abc import Callable
@@ -12,7 +13,7 @@ from functools import cache
 from importlib import import_module
 from inspect import isclass, ismodule, isroutine
 from types import ModuleType, UnionType
-from typing import Any, Union, get_type_hints
+from typing import Any, Self, Union, get_type_hints
 
 from sphinx_codeautolink.parse import Name, NameBreak
 
@@ -72,7 +73,9 @@ def resolve_location(chain: Name, inventory) -> str:
             call_value(cursor)
         elif terminator == NameBreak.for_iter:
             iter_value(cursor)
-    return cursor.location if cursor is not None else None
+    if cursor is None:
+        return None
+    return cursor.location.removeprefix(builtins.__name__ + ".")
 
 
 class CouldNotResolve(Exception):  # noqa: N818
@@ -87,11 +90,25 @@ class Cursor:
     value: Any
     instance: bool
     annotation: Any = None
+    # The live object/class this cursor's value was accessed on, e.g. the
+    # receiver of a bound method. Used to resolve `Self` return annotations
+    # to the accessing class rather than the (possibly different, e.g. a
+    # mixin) class the method happens to be defined on. Unlike `location`,
+    # this is never rewritten by the MRO fallback below, so it reflects the
+    # true runtime receiver even when the naive `location` doesn't resolve.
+    receiver: Any = None
 
 
 def make_cursor(components: list[str]) -> tuple[list[str], Cursor]:
     """Divide components into module and rest, create cursor for following the rest."""
-    value, index = closest_module(tuple(components))
+    try:
+        value, index = closest_module(tuple(components))
+    except CouldNotResolve:
+        if not hasattr(builtins, components[0]):
+            raise
+        # Builtins are documented without a module prefix, so start from
+        # the module itself and let the prefix be stripped on resolution
+        return components, Cursor(builtins.__name__, builtins, instance=False)
     location = ".".join(components[:index])
     return components[index:], Cursor(location, value, instance=False)
 
@@ -121,6 +138,7 @@ def locate_type(cursor: Cursor, components: tuple[str, ...], inventory) -> Curso
             getattr(previous.value, component, None),
             previous.instance,
             annotation=annotation,
+            receiver=previous.value,
         )
 
         if cursor.value is None:
@@ -163,6 +181,21 @@ def call_value(cursor: Cursor) -> None:
         raise CouldNotResolve  # not a function either
 
     annotation = get_return_annotation(cursor.value)
+    if Self is not None and annotation is Self and cursor.receiver is not None:
+        # `Self` refers to whichever class/instance the method was accessed
+        # on, which is not necessarily the class it's defined on (e.g. a
+        # mixin). Use the receiver rather than re-deriving the owner from
+        # `cursor.location`, since that string may have been rewritten to
+        # the *defining* class by the MRO fallback above.
+        owner_value = cursor.receiver
+        if not isclass(owner_value):
+            owner_value = type(owner_value)
+        cursor.value = owner_value
+        cursor.location = fully_qualified_name(owner_value)
+        cursor.instance = True
+        cursor.annotation = annotation
+        return
+
     type_ = origin_type(annotation)
     if not isinstance(type_, type):
         msg = f"Unable to follow return annotation of {annotation!r}."
@@ -201,7 +234,11 @@ def strip_optional(annotation: Any) -> Any:
 
 def origin_type(annotation: Any) -> Any:
     """Return underlying type of an annotation (e.g. ``list`` from ``list[Foo]``)."""
-    return getattr(annotation, "__origin__", None) or annotation
+    origin = getattr(annotation, "__origin__", None)
+    # on 3.14+ the origin of ``X | Y`` is typing.Union, which is a class
+    if origin is Union:
+        return None
+    return origin or annotation
 
 
 def unwrap_iterable(annotation: Any) -> type | None:
@@ -227,7 +264,9 @@ def get_return_annotation(func: Callable) -> Any:
 
 
 def fully_qualified_name(thing: type | Callable) -> str:
-    """Construct the fully qualified name of a type."""
+    """Construct the fully qualified name of a type, omitting the builtins module."""
+    if thing.__module__ == builtins.__name__:
+        return thing.__qualname__
     return thing.__module__ + "." + thing.__qualname__
 
 

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink/parse.py

@@ -6,7 +6,7 @@ import ast
 import builtins
 import sys
 from dataclasses import dataclass
-from enum import Enum
+from enum import StrEnum
 from importlib import import_module
 
 from .warn import logger, warn_type
@@ -83,7 +83,7 @@ class Assignment:
     value: PendingAccess | None
 
 
-class NameBreak(str, Enum):
+class NameBreak(StrEnum):
     """
     Elements that break name access chains.
 
@@ -97,7 +97,7 @@ class NameBreak(str, Enum):
     for_iter = "<>"
 
 
-class LinkContext(str, Enum):
+class LinkContext(StrEnum):
     """Context in which a link appears to help HTML matching."""
 
     none = "none"
@@ -286,15 +286,17 @@ class ImportTrackerVisitor(ast.NodeVisitor):
         if target is None:
             return
 
-        if len(target.components) == 1:
-            comp = target.components[0]
-            if value is None:
-                self.overwrite_name(comp.name)
-            else:
-                self.assign_name(comp.name, value.components)
-                self._create_access(target.components)
+        if len(target.components) != 1:
+            # Dotted targets don't assign to the current scope, and their access
+            # was already resolved when the access chain was visited.
+            return
+
+        comp = target.components[0]
+        if value is None:
+            self.overwrite_name(comp.name)
         else:
-            self.resolve_pending_access(target)
+            self.assign_name(comp.name, value.components)
+            self._create_access(target.components)
 
     def create_simple_access(self, name: str, lineno: int) -> None:
         """Create single-component access to scope."""
@@ -436,6 +438,18 @@ class ImportTrackerVisitor(ast.NodeVisitor):
         target = self.visit(node.target)
         return Assignment([target], value)
 
+    def visit_type_params(self, node: ast.AST) -> None:
+        """Visit bounds and defaults of type parameters."""
+        for param in getattr(node, "type_params", []):
+            self.visit(param)
+
+    def visit_TypeAlias(self, node: ast.AST) -> Assignment:
+        """Visit a type alias statement like an assignment."""
+        value = self.visit(node.value)
+        self.visit_type_params(node)
+        target = self.visit(node.name)
+        return Assignment([target], value)
+
     def visit_AugAssign(self, node: ast.AugAssign) -> None:
         """Visit an AugAssign node."""
         self.visit(node.value)
@@ -499,8 +513,8 @@ class ImportTrackerVisitor(ast.NodeVisitor):
         """Delegate to sync for."""
         self.visit_For(node)
 
-    def visit_For(self, node: ast.For | ast.AsyncFor) -> None:
-        """Swap node order and resolve iterators."""
+    def bind_iter_target(self, node: ast.For | ast.AsyncFor | ast.comprehension):
+        """Visit iterator and bind a simple name target to its element."""
         iter_pending = self.visit(node.iter)
 
         if (
@@ -508,11 +522,15 @@ class ImportTrackerVisitor(ast.NodeVisitor):
             and iter_pending.components
             and isinstance(node.target, ast.Name)
         ):
-            marker = Component(NameBreak.for_iter.value, *linenos(node), "load")
+            marker = Component(NameBreak.for_iter.value, *linenos(node.target), "load")
             self.assign_name(node.target.id, [*iter_pending.components, marker])
         else:
             self.visit(node.target)
 
+    def visit_For(self, node: ast.For | ast.AsyncFor) -> None:
+        """Swap node order and resolve iterators."""
+        self.bind_iter_target(node)
+
         for n in node.body:
             self.visit(n)
         for n in node.orelse:
@@ -526,6 +544,7 @@ class ImportTrackerVisitor(ast.NodeVisitor):
             self.visit(base)
         for kw in node.keywords:
             self.visit(kw)
+        self.visit_type_params(node)
 
         self.overwrite_name(node.name)
         self.pseudo_scopes_stack.append(self.pseudo_scopes_stack[0].copy())
@@ -550,6 +569,7 @@ class ImportTrackerVisitor(ast.NodeVisitor):
             if d is None:
                 continue
             self.visit(d)
+        self.visit_type_params(node)
         args = self._get_args(node.args)
         args += [node.args.vararg, node.args.kwarg]
 
@@ -608,17 +628,17 @@ class ImportTrackerVisitor(ast.NodeVisitor):
         self.visit_generic_comp([node.elt], node.generators)
 
     def visit_DictComp(self, node: ast.DictComp) -> None:
-        """Delegate to generic comp."""
-        self.visit_generic_comp([node.key, node.value], node.generators)
+        """Delegate to generic comp, key is None when unpacking with ``**``."""
+        values = [v for v in (node.key, node.value) if v is not None]
+        self.visit_generic_comp(values, node.generators)
 
     def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
         """Delegate to generic comp."""
         self.visit_generic_comp([node.elt], node.generators)
 
     def visit_comprehension(self, node: ast.comprehension) -> None:
-        """Swap node order."""
-        self.visit(node.iter)
-        self.visit(node.target)
+        """Swap node order and resolve iterators."""
+        self.bind_iter_target(node)
         for f in node.ifs:
             self.visit(f)
 

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sphinx-codeautolink
-Version: 0.18.1
+Version: 0.20.0
 Summary: Automatic links from code examples to reference documentation.
 Author-email: Felix Hildén <felix.hilden@gmail.com>
 Maintainer-email: Felix Hildén <felix.hilden@gmail.com>
@@ -15,15 +15,15 @@ Classifier: Framework :: Sphinx
 Classifier: Framework :: Sphinx :: Extension
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Documentation
 Classifier: Topic :: Documentation :: Sphinx
 Classifier: Topic :: Software Development :: Documentation
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: sphinx>=3.2.0

{sphinx_codeautolink-0.18.1 → sphinx_codeautolink-0.20.0}/src/sphinx_codeautolink.egg-info/SOURCES.txt

@@ -122,12 +122,15 @@ tests/extension/ref/preface_multiline_and_arg.txt
 tests/extension/ref/preface_multiple.txt
 tests/extension/ref/preface_single.txt
 tests/extension/ref/ref_assign_targets.txt
+tests/extension/ref/ref_attribute_assignment.txt
 tests/extension/ref/ref_builtins.txt
 tests/extension/ref/ref_chain.txt
 tests/extension/ref/ref_chain_call.txt
 tests/extension/ref/ref_class_attr.txt
 tests/extension/ref/ref_class_meth_returns_self.txt
 tests/extension/ref/ref_class_type_attr.txt
+tests/extension/ref/ref_comprehension_target.txt
+tests/extension/ref/ref_comprehension_unpack.txt
 tests/extension/ref/ref_decorator.txt
 tests/extension/ref/ref_fluent_attrs.txt
 tests/extension/ref/ref_fluent_call.txt
@@ -147,6 +150,7 @@ tests/extension/ref/ref_inherited.txt
 tests/extension/ref/ref_intersphinx_only.txt
 tests/extension/ref/ref_invalid_func.txt
 tests/extension/ref/ref_invalid_typehint.txt
+tests/extension/ref/ref_lazy_import.txt
 tests/extension/ref/ref_module_attribute.txt
 tests/extension/ref/ref_module_attribute_builtin.txt
 tests/extension/ref/ref_module_attribute_class.txt
@@ -154,9 +158,14 @@ tests/extension/ref/ref_optional.txt
 tests/extension/ref/ref_optional_future.txt
 tests/extension/ref/ref_shadow_builtin.txt
 tests/extension/ref/ref_simple.txt
+tests/extension/ref/ref_type_alias.txt
 tests/extension/ref/ref_type_checking_aliased.txt
 tests/extension/ref/ref_type_checking_gated.txt
+tests/extension/ref/ref_type_param_defaults.txt
+tests/extension/ref/ref_type_params.txt
+tests/extension/ref/ref_union_return.txt
 tests/extension/ref/search_css_duplicates_removed.txt
+tests/extension/ref/self_type.txt
 tests/extension/ref/skip_file.txt
 tests/extension/ref/skip_next.txt
 tests/extension/ref/skip_next_consumed_non_python.txt
@@ -165,6 +174,7 @@ tests/extension/ref/skip_section.txt
 tests/extension/src/class_mro_fix.py
 tests/extension/src/future_project.py
 tests/extension/src/parser_func.py
+tests/extension/src/self_type.py
 tests/extension/src/test_project/__init__.py
 tests/extension/src/test_project/sub.py
 tests/extension/src/type_checking/__init__.py