Sphinx 7.2.6__py3-none-any.whl → 7.3.0__py3-none-any.whl

sphinx/util/inventory.py

@@ -25,7 +25,7 @@ class InventoryFileReader:
     This reader supports mixture of texts and compressed texts.
     """
 
-    def __init__(self, stream: IO) -> None:
+    def __init__(self, stream: IO[bytes]) -> None:
         self.stream = stream
         self.buffer = b''
         self.eof = False
@@ -77,7 +77,12 @@ class InventoryFileReader:
 
 class InventoryFile:
     @classmethod
-    def load(cls, stream: IO, uri: str, joinfunc: Callable) -> Inventory:
+    def load(
+        cls: type[InventoryFile],
+        stream: IO[bytes],
+        uri: str,
+        joinfunc: Callable[[str, str], str],
+    ) -> Inventory:
         reader = InventoryFileReader(stream)
         line = reader.readline().rstrip()
         if line == '# Sphinx inventory version 1':
@@ -88,7 +93,12 @@ class InventoryFile:
             raise ValueError('invalid inventory header: %s' % line)
 
     @classmethod
-    def load_v1(cls, stream: InventoryFileReader, uri: str, join: Callable) -> Inventory:
+    def load_v1(
+        cls: type[InventoryFile],
+        stream: InventoryFileReader,
+        uri: str,
+        join: Callable[[str, str], str],
+    ) -> Inventory:
         invdata: Inventory = {}
         projname = stream.readline().rstrip()[11:]
         version = stream.readline().rstrip()[11:]
@@ -106,7 +116,12 @@ class InventoryFile:
         return invdata
 
     @classmethod
-    def load_v2(cls, stream: InventoryFileReader, uri: str, join: Callable) -> Inventory:
+    def load_v2(
+        cls: type[InventoryFile],
+        stream: InventoryFileReader,
+        uri: str,
+        join: Callable[[str, str], str],
+    ) -> Inventory:
         invdata: Inventory = {}
         projname = stream.readline().rstrip()[11:]
         version = stream.readline().rstrip()[11:]
@@ -140,7 +155,9 @@ class InventoryFile:
         return invdata
 
     @classmethod
-    def dump(cls, filename: str, env: BuildEnvironment, builder: Builder) -> None:
+    def dump(
+        cls: type[InventoryFile], filename: str, env: BuildEnvironment, builder: Builder,
+    ) -> None:
         def escape(string: str) -> str:
             return re.sub("\\s+", " ", string)
 

sphinx/util/logging.py

@@ -16,7 +16,7 @@ from sphinx.util.console import colorize
 from sphinx.util.osutil import abspath
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Iterator
 
     from docutils.nodes import Node
 
@@ -85,6 +85,7 @@ def convert_serializable(records: list[logging.LogRecord]) -> None:
 
 class SphinxLogRecord(logging.LogRecord):
     """Log record class supporting location"""
+
     prefix = ''
     location: Any = None
 
@@ -101,11 +102,13 @@ class SphinxLogRecord(logging.LogRecord):
 
 class SphinxInfoLogRecord(SphinxLogRecord):
     """Info log record class supporting location"""
+
     prefix = ''  # do not show any prefix for INFO messages
 
 
 class SphinxWarningLogRecord(SphinxLogRecord):
     """Warning log record class supporting location"""
+
     @property
     def prefix(self) -> str:  # type: ignore[override]
         if self.levelno >= logging.CRITICAL:
@@ -118,6 +121,7 @@ class SphinxWarningLogRecord(SphinxLogRecord):
 
 class SphinxLoggerAdapter(logging.LoggerAdapter):
     """LoggerAdapter allowing ``type`` and ``subtype`` keywords."""
+
     KEYWORDS = ['type', 'subtype', 'location', 'nonl', 'color', 'once']
 
     def log(  # type: ignore[override]
@@ -143,9 +147,56 @@ class SphinxLoggerAdapter(logging.LoggerAdapter):
     def handle(self, record: logging.LogRecord) -> None:
         self.logger.handle(record)
 
+    def warning(  # type: ignore[override]
+        self,
+        msg: object,
+        *args: object,
+        type: None | str = None,
+        subtype: None | str = None,
+        location: None | str | tuple[str | None, int | None] | Node = None,
+        nonl: bool = True,
+        color: str | None = None,
+        once: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        """Log a sphinx warning.
+
+        It is recommended to include a ``type`` and ``subtype`` for warnings as
+        these can be displayed to the user using :confval:`show_warning_types`
+        and used in :confval:`suppress_warnings` to suppress specific warnings.
+
+        It is also recommended to specify a ``location`` whenever possible
+        to help users in correcting the warning.
+
+        :param msg: The message, which may contain placeholders for ``args``.
+        :param args: The arguments to substitute into ``msg``.
+        :param type: The type of the warning.
+        :param subtype: The subtype of the warning.
+        :param location: The source location of the warning's origin,
+            which can be a string (the ``docname`` or ``docname:lineno``),
+            a tuple of ``(docname, lineno)``,
+            or the docutils node object.
+        :param nonl: Whether to append a new line terminator to the message.
+        :param color: A color code for the message.
+        :param once: Do not log this warning,
+            if a previous warning already has same ``msg``, ``args`` and ``once=True``.
+        """
+        return super().warning(
+            msg,
+            *args,
+            type=type,
+            subtype=subtype,
+            location=location,
+            nonl=nonl,
+            color=color,
+            once=once,
+            **kwargs,
+        )
+
 
 class WarningStreamHandler(logging.StreamHandler):
     """StreamHandler for warnings."""
+
     pass
 
 
@@ -195,7 +246,7 @@ class MemoryHandler(logging.handlers.BufferingHandler):
 
 
 @contextmanager
-def pending_warnings() -> Generator[logging.Handler, None, None]:
+def pending_warnings() -> Iterator[logging.Handler]:
     """Context manager to postpone logging warnings temporarily.
 
     Similar to :func:`pending_logging`.
@@ -223,7 +274,7 @@ def pending_warnings() -> Generator[logging.Handler, None, None]:
 
 
 @contextmanager
-def suppress_logging() -> Generator[MemoryHandler, None, None]:
+def suppress_logging() -> Iterator[MemoryHandler]:
     """Context manager to suppress logging all logs temporarily.
 
     For example::
@@ -252,7 +303,7 @@ def suppress_logging() -> Generator[MemoryHandler, None, None]:
 
 
 @contextmanager
-def pending_logging() -> Generator[MemoryHandler, None, None]:
+def pending_logging() -> Iterator[MemoryHandler]:
     """Context manager to postpone logging all logs temporarily.
 
     For example::
@@ -272,7 +323,7 @@ def pending_logging() -> Generator[MemoryHandler, None, None]:
 
 
 @contextmanager
-def skip_warningiserror(skip: bool = True) -> Generator[None, None, None]:
+def skip_warningiserror(skip: bool = True) -> Iterator[None]:
     """Context manager to skip WarningIsErrorFilter temporarily."""
     logger = logging.getLogger(NAMESPACE)
 
@@ -292,7 +343,7 @@ def skip_warningiserror(skip: bool = True) -> Generator[None, None, None]:
 
 
 @contextmanager
-def prefixed_warnings(prefix: str) -> Generator[None, None, None]:
+def prefixed_warnings(prefix: str) -> Iterator[None]:
     """Context manager to prepend prefix to all warning log records temporarily.
 
     For example::
@@ -342,7 +393,7 @@ class LogCollector:
         self.logs: list[logging.LogRecord] = []
 
     @contextmanager
-    def collect(self) -> Generator[None, None, None]:
+    def collect(self) -> Iterator[None]:
         with pending_logging() as memhandler:
             yield
 
@@ -475,7 +526,9 @@ class SphinxLogRecordTranslator(logging.Filter):
 
     * Make a instance of SphinxLogRecord
     * docname to path if location given
+    * append warning type/subtype to message if :confval:`show_warning_types` is ``True``
     """
+
     LogRecordClass: type[logging.LogRecord]
 
     def __init__(self, app: Sphinx) -> None:
@@ -507,13 +560,32 @@ class SphinxLogRecordTranslator(logging.Filter):
 
 class InfoLogRecordTranslator(SphinxLogRecordTranslator):
     """LogRecordTranslator for INFO level log records."""
+
     LogRecordClass = SphinxInfoLogRecord
 
 
 class WarningLogRecordTranslator(SphinxLogRecordTranslator):
     """LogRecordTranslator for WARNING level log records."""
+
     LogRecordClass = SphinxWarningLogRecord
 
+    def filter(self, record: SphinxWarningLogRecord) -> bool:  # type: ignore[override]
+        ret = super().filter(record)
+
+        try:
+            show_warning_types = self.app.config.show_warning_types
+        except AttributeError:
+            # config is not initialized yet (ex. in conf.py)
+            show_warning_types = False
+        if show_warning_types:
+            if log_type := getattr(record, 'type', ''):
+                if log_subtype := getattr(record, 'subtype', ''):
+                    record.msg += f' [{log_type}.{log_subtype}]'
+                else:
+                    record.msg += f' [{log_type}]'
+
+        return ret
+
 
 def get_node_location(node: Node) -> str | None:
     source, line = get_source_line(node)
@@ -543,6 +615,7 @@ class ColorizeFormatter(logging.Formatter):
 
 class SafeEncodingWriter:
     """Stream writer which ignores UnicodeEncodeError silently"""
+
     def __init__(self, stream: IO) -> None:
         self.stream = stream
         self.encoding = getattr(stream, 'encoding', 'ascii') or 'ascii'
@@ -562,6 +635,7 @@ class SafeEncodingWriter:
 
 class LastMessagesWriter:
     """Stream writer storing last 10 messages in memory to save trackback"""
+
     def __init__(self, app: Sphinx, stream: IO) -> None:
         self.app = app
 

sphinx/util/matching.py

@@ -91,7 +91,8 @@ _pat_cache: dict[str, re.Pattern[str]] = {}
 
 def patmatch(name: str, pat: str) -> re.Match[str] | None:
     """Return if name matches the regular expression (pattern)
-    ``pat```. Adapted from fnmatch module."""
+    ``pat```. Adapted from fnmatch module.
+    """
     if pat not in _pat_cache:
         _pat_cache[pat] = re.compile(_translate_pattern(pat))
     return _pat_cache[pat].match(name)

sphinx/util/math.py

@@ -54,8 +54,7 @@ def wrap_displaymath(text: str, label: str | None, numbering: bool) -> str:
         else:
             begin = r'\begin{align*}%s\!\begin{aligned}' % labeldef
             end = r'\end{aligned}\end{align*}'
-        for part in parts:
-            equations.append('%s\\\\\n' % part.strip())
+        equations.extend('%s\\\\\n' % part.strip() for part in parts)
 
     concatenated_equations = ''.join(equations)
     return f'{begin}\n{concatenated_equations}{end}'

sphinx/util/nodes.py

@@ -5,18 +5,19 @@ from __future__ import annotations
 import contextlib
 import re
 import unicodedata
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast
 
 from docutils import nodes
+from docutils.nodes import Node
 
 from sphinx import addnodes
 from sphinx.locale import __
 from sphinx.util import logging
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Iterable, Iterator
 
-    from docutils.nodes import Element, Node
+    from docutils.nodes import Element
     from docutils.parsers.rst import Directive
     from docutils.parsers.rst.states import Inliner
     from docutils.statemachine import StringList
@@ -33,7 +34,10 @@ explicit_title_re = re.compile(r'^(.+?)\s*(?<!\x00)<([^<]*?)>$', re.DOTALL)
 caption_ref_re = explicit_title_re  # b/w compat alias
 
 
-class NodeMatcher:
+N = TypeVar("N", bound=Node)
+
+
+class NodeMatcher(Generic[N]):
     """A helper class for Node.findall().
 
     It checks that the given node is an instance of the specified node-classes and
@@ -43,20 +47,18 @@ class NodeMatcher:
     and ``reftype`` attributes::
 
         matcher = NodeMatcher(nodes.reference, refdomain='std', reftype='citation')
-        doctree.findall(matcher)
+        matcher.findall(doctree)
         # => [<reference ...>, <reference ...>, ...]
 
     A special value ``typing.Any`` matches any kind of node-attributes.  For example,
     following example searches ``reference`` node having ``refdomain`` attributes::
 
-        from __future__ import annotations
-from typing import TYPE_CHECKING, Any
         matcher = NodeMatcher(nodes.reference, refdomain=Any)
-        doctree.findall(matcher)
+        matcher.findall(doctree)
         # => [<reference ...>, <reference ...>, ...]
     """
 
-    def __init__(self, *node_classes: type[Node], **attrs: Any) -> None:
+    def __init__(self, *node_classes: type[N], **attrs: Any) -> None:
         self.classes = node_classes
         self.attrs = attrs
 
@@ -85,6 +87,15 @@ from typing import TYPE_CHECKING, Any
     def __call__(self, node: Node) -> bool:
         return self.match(node)
 
+    def findall(self, node: Node) -> Iterator[N]:
+        """An alternative to `Node.findall` with improved type safety.
+
+        While the `NodeMatcher` object can be used as an argument to `Node.findall`, doing so
+        confounds type checkers' ability to determine the return type of the iterator.
+        """
+        for found in node.findall(self):
+            yield cast(N, found)
+
 
 def get_full_module_name(node: Node) -> str:
     """
@@ -99,7 +110,7 @@ def get_full_module_name(node: Node) -> str:
 def repr_domxml(node: Node, length: int = 80) -> str:
     """
     return DOM XML representation of the specified node like:
-    '<paragraph translatable="False"><inline classes="versionmodified">New in version...'
+    '<paragraph translatable="False"><inline classes="versionadded">Added in version...'
 
     :param nodes.Node node: target node
     :param int length:
@@ -127,7 +138,7 @@ def apply_source_workaround(node: Element) -> None:
                      get_full_module_name(node), repr_domxml(node))
         definition_list_item = node.parent
         node.source = definition_list_item.source
-        node.line = definition_list_item.line - 1
+        node.line = definition_list_item.line - 1  # type: ignore[operator]
         node.rawsource = node.astext()  # set 'classifier1' (or 'classifier2')
     elif isinstance(node, nodes.classifier) and not node.source:
         # docutils-0.15 fills in rawsource attribute, but not in source.
@@ -220,16 +231,13 @@ def is_translatable(node: Node) -> bool:
             return False
         # <field_name>orphan</field_name>
         # XXX ignore all metadata (== docinfo)
-        if isinstance(node, nodes.field_name) and node.children[0] == 'orphan':
+        if isinstance(node, nodes.field_name) and (node.children[0] == 'orphan'):
             logger.debug('[i18n] SKIP %r because orphan node: %s',
                          get_full_module_name(node), repr_domxml(node))
             return False
         return True
 
-    if isinstance(node, nodes.meta):  # type: ignore[attr-defined]
-        return True
-
-    return False
+    return isinstance(node, nodes.meta)
 
 
 LITERAL_TYPE_NODES = (
@@ -245,10 +253,10 @@ IMAGE_TYPE_NODES = (
 
 def extract_messages(doctree: Element) -> Iterable[tuple[Element, str]]:
     """Extract translatable messages from a document tree."""
-    for node in doctree.findall(is_translatable):  # type: Element
+    for node in doctree.findall(is_translatable):
         if isinstance(node, addnodes.translatable):
             for msg in node.extract_original_messages():
-                yield node, msg
+                yield node, msg  # type: ignore[misc]
             continue
         if isinstance(node, LITERAL_TYPE_NODES):
             msg = node.rawsource
@@ -262,14 +270,14 @@ def extract_messages(doctree: Element) -> Iterable[tuple[Element, str]]:
                 msg = f'.. image:: {image_uri}'
             else:
                 msg = ''
-        elif isinstance(node, nodes.meta):  # type: ignore[attr-defined]
+        elif isinstance(node, nodes.meta):
             msg = node["content"]
         else:
-            msg = node.rawsource.replace('\n', ' ').strip()
+            msg = node.rawsource.replace('\n', ' ').strip()  # type: ignore[attr-defined]
 
         # XXX nodes rendering empty are likely a bug in sphinx.addnodes
         if msg:
-            yield node, msg
+            yield node, msg  # type: ignore[misc]
 
 
 def get_node_source(node: Element) -> str:
@@ -308,7 +316,7 @@ def traverse_translatable_index(
 ) -> Iterable[tuple[Element, list[tuple[str, str, str, str, str | None]]]]:
     """Traverse translatable index node from a document tree."""
     matcher = NodeMatcher(addnodes.index, inline=False)
-    for node in doctree.findall(matcher):  # type: addnodes.index
+    for node in matcher.findall(doctree):
         if 'raw_entries' in node:
             entries = node['raw_entries']
         else:
@@ -402,9 +410,14 @@ def process_index_entry(entry: str, targetid: str,
     return indexentries
 
 
-def inline_all_toctrees(builder: Builder, docnameset: set[str], docname: str,
-                        tree: nodes.document, colorfunc: Callable, traversed: list[str],
-                        ) -> nodes.document:
+def inline_all_toctrees(
+    builder: Builder,
+    docnameset: set[str],
+    docname: str,
+    tree: nodes.document,
+    colorfunc: Callable[[str], str],
+    traversed: list[str],
+) -> nodes.document:
     """Inline all toctrees in the *tree*.
 
     Record all docnames in *docnameset*, and output docnames with *colorfunc*.
@@ -599,10 +612,7 @@ def is_smartquotable(node: Node) -> bool:
         if pnode.get('support_smartquotes', None) is False:
             return False
 
-    if getattr(node, 'support_smartquotes', None) is False:
-        return False
-
-    return True
+    return getattr(node, 'support_smartquotes', None) is not False
 
 
 def process_only_nodes(document: Node, tags: Tags) -> None:

sphinx/util/osutil.py

@@ -11,12 +11,14 @@ import sys
 import unicodedata
 from io import StringIO
 from os import path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from sphinx.deprecation import _deprecation_warning
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
+    from types import TracebackType
+    from typing import Any
 
 # SEP separates path elements in the canonical file names
 #
@@ -36,7 +38,7 @@ def canon_path(native_path: str | os.PathLike[str], /) -> str:
 
 
 def path_stabilize(filepath: str | os.PathLike[str], /) -> str:
-    "Normalize path separator and unicode string"
+    """Normalize path separator and unicode string"""
     new_path = canon_path(filepath)
     return unicodedata.normalize('NFC', new_path)
 
@@ -88,7 +90,16 @@ def copytimes(source: str | os.PathLike[str], dest: str | os.PathLike[str]) -> N
 def copyfile(source: str | os.PathLike[str], dest: str | os.PathLike[str]) -> None:
     """Copy a file and its modification times, if possible.
 
-    Note: ``copyfile`` skips copying if the file has not been changed"""
+    :param source: An existing source to copy.
+    :param dest: The destination path.
+    :raise FileNotFoundError: The *source* does not exist.
+
+    .. note:: :func:`copyfile` is a no-op if *source* and *dest* are identical.
+    """
+    if not path.exists(source):
+        msg = f'{os.fsdecode(source)} does not exist'
+        raise FileNotFoundError(msg)
+
     if not path.exists(dest) or not filecmp.cmp(source, dest):
         shutil.copyfile(source, dest)
         with contextlib.suppress(OSError):
@@ -131,15 +142,22 @@ abspath = path.abspath
 
 class _chdir:
     """Remove this fall-back once support for Python 3.10 is removed."""
-    def __init__(self, target_dir: str, /):
+
+    def __init__(self, target_dir: str, /) -> None:
         self.path = target_dir
         self._dirs: list[str] = []
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         self._dirs.append(os.getcwd())
         os.chdir(self.path)
 
-    def __exit__(self, _exc_type, _exc_value, _traceback, /):
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: TracebackType | None,
+        /,
+    ) -> None:
         os.chdir(self._dirs.pop())
 
 
@@ -163,6 +181,7 @@ class FileAvoidWrite:
 
     Objects can be used as context managers.
     """
+
     def __init__(self, path: str) -> None:
         self._path = path
         self._io: StringIO | None = None

sphinx/util/parallel.py

@@ -94,7 +94,12 @@ class ParallelTasks:
         proc = context.Process(target=self._process, args=(psend, task_func, arg))
         self._procs[tid] = proc
         self._precvsWaiting[tid] = precv
-        self._join_one()
+        try:
+            self._join_one()
+        except Exception:
+            # shutdown other child processes on failure
+            # (e.g. OSError: Failed to allocate memory)
+            self.terminate()
 
     def join(self) -> None:
         try:

sphinx/util/requests.py

@@ -30,17 +30,19 @@ def _get_tls_cacert(url: str, certs: str | dict[str, str] | None) -> str | bool:
 
 
 def get(url: str, **kwargs: Any) -> requests.Response:
-    """Sends a GET request like requests.get().
+    """Sends a GET request like ``requests.get()``.
 
-    This sets up User-Agent header and TLS verification automatically."""
+    This sets up User-Agent header and TLS verification automatically.
+    """
     with _Session() as session:
         return session.get(url, **kwargs)
 
 
 def head(url: str, **kwargs: Any) -> requests.Response:
-    """Sends a HEAD request like requests.head().
+    """Sends a HEAD request like ``requests.head()``.
 
-    This sets up User-Agent header and TLS verification automatically."""
+    This sets up User-Agent header and TLS verification automatically.
+    """
     with _Session() as session:
         return session.head(url, **kwargs)
 
@@ -54,7 +56,8 @@ class _Session(requests.Session):
     ) -> requests.Response:
         """Sends a request with an HTTP verb and url.
 
-        This sets up User-Agent header and TLS verification automatically."""
+        This sets up User-Agent header and TLS verification automatically.
+        """
         headers = kwargs.setdefault('headers', {})
         headers.setdefault('User-Agent', _user_agent or _USER_AGENT)
         if _tls_info:

sphinx/util/rst.py

@@ -5,11 +5,11 @@ from __future__ import annotations
 import re
 from collections import defaultdict
 from contextlib import contextmanager
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 from unicodedata import east_asian_width
 
 from docutils.parsers.rst import roles
-from docutils.parsers.rst.languages import en as english
+from docutils.parsers.rst.languages import en as english  # type: ignore[attr-defined]
 from docutils.parsers.rst.states import Body
 from docutils.utils import Reporter
 from jinja2 import Environment, pass_environment
@@ -18,7 +18,7 @@ from sphinx.locale import __
 from sphinx.util import docutils, logging
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Iterator
 
     from docutils.statemachine import StringList
 
@@ -54,17 +54,18 @@ def textwidth(text: str, widechars: str = 'WF') -> int:
 def heading(env: Environment, text: str, level: int = 1) -> str:
     """Create a heading for *level*."""
     assert level <= 3
-    width = textwidth(text, WIDECHARS[env.language])
+    # ``env.language`` is injected by ``sphinx.util.template.ReSTRenderer``
+    width = textwidth(text, WIDECHARS[env.language])  # type: ignore[attr-defined]
     sectioning_char = SECTIONING_CHARS[level - 1]
     return f'{text}\n{sectioning_char * width}'
 
 
 @contextmanager
-def default_role(docname: str, name: str) -> Generator[None, None, None]:
+def default_role(docname: str, name: str) -> Iterator[None]:
     if name:
         dummy_reporter = Reporter('', 4, 4)
         role_fn, _ = roles.role(name, english, 0, dummy_reporter)
-        if role_fn:  # type: ignore[truthy-function]
+        if role_fn:
             docutils.register_role('', role_fn)  # type: ignore[arg-type]
         else:
             logger.warning(__('default role %s not found'), name, location=docname)
@@ -102,6 +103,7 @@ def append_epilog(content: StringList, epilog: str) -> None:
     if epilog:
         if len(content) > 0:
             source, lineno = content.info(-1)
+            lineno = cast(int, lineno)  # lineno will never be None, since len(content) > 0
         else:
             source = '<generated>'
             lineno = 0

sphinx/util/tags.py

@@ -20,8 +20,8 @@ class BooleanParser(Parser):
     Only allow condition exprs and/or/not operations.
     """
 
-    def parse_compare(self) -> Node:
-        node: Node
+    def parse_compare(self) -> nodes.Expr:
+        node: nodes.Expr
         token = self.stream.current
         if token.type == 'name':
             if token.value in ('true', 'false', 'True', 'False'):
@@ -67,7 +67,7 @@ class Tags:
             msg = 'chunk after expression'
             raise ValueError(msg)
 
-        def eval_node(node: Node) -> bool:
+        def eval_node(node: Node | None) -> bool:
             if isinstance(node, nodes.CondExpr):
                 if eval_node(node.test):
                     return eval_node(node.expr1)