Sphinx 7.4.6__py3-none-any.whl → 8.0.0rc1__py3-none-any.whl

sphinx/__init__.py

@@ -1,6 +1,6 @@
 """The Sphinx documentation toolchain."""
 
-__version__ = '7.4.6'
+__version__ = '8.0.0rc1'
 __display_version__ = __version__  # used for command line version
 
 # Keep this file executable as-is in Python 3!
@@ -27,7 +27,7 @@ warnings.filterwarnings(
 #:
 #: .. versionadded:: 1.2
 #:    Before version 1.2, check the string ``sphinx.__version__``.
-version_info = (7, 4, 6, 'final', 0)
+version_info = (8, 0, 0, 'candidate', 1)
 
 package_dir = os.path.abspath(os.path.dirname(__file__))
 

sphinx/_cli/__init__.py

@@ -36,10 +36,10 @@ from sphinx.locale import __, init_console
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Iterator, Sequence
-    from typing import NoReturn
+    from typing import NoReturn, TypeAlias
 
-    _PARSER_SETUP = Callable[[argparse.ArgumentParser], argparse.ArgumentParser]
-    _RUNNER = Callable[[argparse.Namespace], int]
+    _PARSER_SETUP: TypeAlias = Callable[[argparse.ArgumentParser], argparse.ArgumentParser]
+    _RUNNER: TypeAlias = Callable[[argparse.Namespace], int]
 
     from typing import Protocol
 
@@ -79,7 +79,7 @@ class _RootArgumentParser(argparse.ArgumentParser):
         ]
 
         if commands := list(_load_subcommand_descriptions()):
-            command_max_length = min(max(map(len, next(zip(*commands), ()))), 22)
+            command_max_length = min(max(map(len, next(zip(*commands, strict=True), ()))), 22)
             help_fragments += [
                 '\n',
                 bold(underline(__('Commands:'))),

sphinx/application.py

@@ -10,10 +10,11 @@ import os
 import pickle
 import sys
 from collections import deque
-from collections.abc import Collection, Sequence  # NoQA: TCH003
+from collections.abc import Callable, Collection, Sequence  # NoQA: TCH003
 from io import StringIO
 from os import path
-from typing import IO, TYPE_CHECKING, Any, Callable, Literal
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any, Literal
 
 from docutils.nodes import TextElement  # NoQA: TCH002
 from docutils.parsers.rst import Directive, roles
@@ -31,7 +32,6 @@ from sphinx.locale import __
 from sphinx.project import Project
 from sphinx.registry import SphinxComponentRegistry
 from sphinx.util import docutils, logging
-from sphinx.util._pathlib import _StrPath
 from sphinx.util.build_phase import BuildPhase
 from sphinx.util.console import bold
 from sphinx.util.display import progress_message
@@ -173,9 +173,9 @@ class Sphinx:
         self.registry = SphinxComponentRegistry()
 
         # validate provided directories
-        self.srcdir = _StrPath(srcdir).resolve()
-        self.outdir = _StrPath(outdir).resolve()
-        self.doctreedir = _StrPath(doctreedir).resolve()
+        self.srcdir = Path(srcdir).resolve()
+        self.outdir = Path(outdir).resolve()
+        self.doctreedir = Path(doctreedir).resolve()
 
         if not path.isdir(self.srcdir):
             raise ApplicationError(__('Cannot find source directory (%s)') %
@@ -231,7 +231,7 @@ class Sphinx:
             self.confdir = self.srcdir
             self.config = Config({}, confoverrides or {})
         else:
-            self.confdir = _StrPath(confdir).resolve()
+            self.confdir = Path(confdir).resolve()
             self.config = Config.read(self.confdir, confoverrides or {}, self.tags)
 
         # set up translation infrastructure

sphinx/builders/__init__.py

@@ -38,7 +38,6 @@ if TYPE_CHECKING:
     from sphinx.config import Config
     from sphinx.events import EventManager
     from sphinx.util.tags import Tags
-    from sphinx.util.typing import NoneType
 
 
 logger = logging.getLogger(__name__)
@@ -520,7 +519,7 @@ class Builder:
         if path.isfile(docutilsconf):
             self.env.note_dependency(docutilsconf)
 
-        filename = self.env.doc2path(docname)
+        filename = str(self.env.doc2path(docname))
         filetype = get_filetype(self.app.config.source_suffix, filename)
         publisher = self.app.registry.get_publisher(self.app, filetype)
         self.env.temp_data['_parser'] = publisher.parser
@@ -645,7 +644,7 @@ class Builder:
         progress = status_iterator(chunks, __('writing output... '), "darkgreen",
                                    len(chunks), self.app.verbosity)
 
-        def on_chunk_done(args: list[tuple[str, NoneType]], result: NoneType) -> None:
+        def on_chunk_done(args: list[tuple[str, nodes.document]], result: None) -> None:
             next(progress)
 
         self.app.phase = BuildPhase.RESOLVING

sphinx/builders/_epub_base.py

@@ -27,8 +27,9 @@ if TYPE_CHECKING:
 
 try:
     from PIL import Image
+    PILLOW_AVAILABLE = True
 except ImportError:
-    Image = None
+    PILLOW_AVAILABLE = False
 
 
 logger = logging.getLogger(__name__)
@@ -107,8 +108,8 @@ class NavPoint(NamedTuple):
 
 def sphinx_smarty_pants(t: str, language: str = 'en') -> str:
     t = t.replace('"', '"')
-    t = smartquotes.educateDashesOldSchool(t)
-    t = smartquotes.educateQuotes(t, language)
+    t = smartquotes.educateDashesOldSchool(t)  # type: ignore[no-untyped-call]
+    t = smartquotes.educateQuotes(t, language)  # type: ignore[no-untyped-call]
     t = t.replace('"', '"')
     return t
 
@@ -411,8 +412,11 @@ class EpubBuilder(StandaloneHTMLBuilder):
                     logger.warning(__('cannot read image file %r: copying it instead'),
                                    path.join(self.srcdir, src))
                 try:
-                    copyfile(path.join(self.srcdir, src),
-                             path.join(self.outdir, self.imagedir, dest))
+                    copyfile(
+                        self.srcdir / src,
+                        self.outdir / self.imagedir / dest,
+                        force=True,
+                    )
                 except OSError as err:
                     logger.warning(__('cannot copy image file %r: %s'),
                                    path.join(self.srcdir, src), err)
@@ -440,7 +444,7 @@ class EpubBuilder(StandaloneHTMLBuilder):
         """
         if self.images:
             if self.config.epub_fix_images or self.config.epub_max_image_width:
-                if not Image:
+                if not PILLOW_AVAILABLE:
                     logger.warning(__('Pillow not found - copying image files'))
                     super().copy_image_files()
                 else:
@@ -474,14 +478,22 @@ class EpubBuilder(StandaloneHTMLBuilder):
     def build_mimetype(self) -> None:
         """Write the metainfo file mimetype."""
         logger.info(__('writing mimetype file...'))
-        copy_asset_file(path.join(self.template_dir, 'mimetype'), self.outdir)
+        copyfile(
+            path.join(self.template_dir, 'mimetype'),
+            self.outdir / 'mimetype',
+            force=True,
+        )
 
     def build_container(self, outname: str = 'META-INF/container.xml') -> None:
         """Write the metainfo file META-INF/container.xml."""
         logger.info(__('writing META-INF/container.xml file...'))
-        outdir = path.join(self.outdir, 'META-INF')
+        outdir = self.outdir / 'META-INF'
         ensuredir(outdir)
-        copy_asset_file(path.join(self.template_dir, 'container.xml'), outdir)
+        copyfile(
+            path.join(self.template_dir, 'container.xml'),
+            outdir / 'container.xml',
+            force=True,
+        )
 
     def content_metadata(self) -> dict[str, Any]:
         """Create a dictionary with all metadata for the content.opf
@@ -621,7 +633,12 @@ class EpubBuilder(StandaloneHTMLBuilder):
                                             html.escape(self.refnodes[0]['refuri'])))
 
         # write the project file
-        copy_asset_file(path.join(self.template_dir, 'content.opf.jinja'), self.outdir, metadata)  # NoQA: E501
+        copy_asset_file(
+            path.join(self.template_dir, 'content.opf.jinja'),
+            self.outdir,
+            context=metadata,
+            force=True,
+        )
 
     def new_navpoint(self, node: dict[str, Any], level: int, incr: bool = True) -> NavPoint:
         """Create a new entry in the toc from the node at given level."""
@@ -704,8 +721,12 @@ class EpubBuilder(StandaloneHTMLBuilder):
         navpoints = self.build_navpoints(refnodes)
         level = max(item['level'] for item in self.refnodes)
         level = min(level, self.config.epub_tocdepth)
-        copy_asset_file(path.join(self.template_dir, 'toc.ncx.jinja'), self.outdir,
-                        self.toc_metadata(level, navpoints))
+        copy_asset_file(
+            path.join(self.template_dir, 'toc.ncx.jinja'),
+            self.outdir,
+            context=self.toc_metadata(level, navpoints),
+            force=True,
+        )
 
     def build_epub(self) -> None:
         """Write the epub file.

sphinx/builders/changes.py

@@ -134,16 +134,24 @@ class ChangesBuilder(Builder):
             with open(targetfn, 'w', encoding='utf-8') as f:
                 text = ''.join(hl(i + 1, line) for (i, line) in enumerate(lines))
                 ctx = {
-                    'filename': self.env.doc2path(docname, False),
+                    'filename': str(self.env.doc2path(docname, False)),
                     'text': text,
                 }
                 f.write(self.templates.render('changes/rstsource.html', ctx))
         themectx = {'theme_' + key: val for (key, val) in
                     self.theme.get_options({}).items()}
-        copy_asset_file(path.join(package_dir, 'themes', 'default', 'static', 'default.css.jinja'),  # NoQA: E501
-                        self.outdir, context=themectx, renderer=self.templates)
-        copy_asset_file(path.join(package_dir, 'themes', 'basic', 'static', 'basic.css'),
-                        self.outdir)
+        copy_asset_file(
+            path.join(package_dir, 'themes', 'default', 'static', 'default.css.jinja'),
+            self.outdir,
+            context=themectx,
+            renderer=self.templates,
+            force=True,
+        )
+        copy_asset_file(
+            path.join(package_dir, 'themes', 'basic', 'static', 'basic.css'),
+            self.outdir / 'basic.css',
+            force=True,
+        )
 
     def hl(self, text: str, version: str) -> str:
         text = html.escape(text)

sphinx/builders/epub3.py

@@ -194,8 +194,12 @@ class Epub3Builder(_epub_base.EpubBuilder):
             # 'includehidden'
             refnodes = self.refnodes
         navlist = self.build_navlist(refnodes)
-        copy_asset_file(path.join(self.template_dir, 'nav.xhtml.jinja'), self.outdir,
-                        self.navigation_doc_metadata(navlist))
+        copy_asset_file(
+            path.join(self.template_dir, 'nav.xhtml.jinja'),
+            self.outdir,
+            context=self.navigation_doc_metadata(navlist),
+            force=True,
+        )
 
         # Add nav.xhtml to epub file
         if 'nav.xhtml' not in self.files:

sphinx/builders/html/__init__.py

@@ -9,10 +9,10 @@ import os
 import posixpath
 import re
 import sys
-import time
 import types
 import warnings
 from os import path
+from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any
 from urllib.parse import quote
 
@@ -39,18 +39,27 @@ from sphinx.locale import _, __
 from sphinx.search import js_index
 from sphinx.theming import HTMLThemeFactory
 from sphinx.util import isurl, logging
+from sphinx.util._timestamps import _format_rfc3339_microseconds
 from sphinx.util.display import progress_message, status_iterator
 from sphinx.util.docutils import new_document
 from sphinx.util.fileutil import copy_asset
 from sphinx.util.i18n import format_date
 from sphinx.util.inventory import InventoryFile
 from sphinx.util.matching import DOTFILES, Matcher, patmatch
-from sphinx.util.osutil import SEP, copyfile, ensuredir, os_path, relative_uri
+from sphinx.util.osutil import (
+    SEP,
+    _last_modified_time,
+    copyfile,
+    ensuredir,
+    os_path,
+    relative_uri,
+)
 from sphinx.writers.html import HTMLWriter
 from sphinx.writers.html5 import HTML5Translator
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Set
+    from typing import TypeAlias
 
     from docutils.nodes import Node
     from docutils.readers import Reader
@@ -67,7 +76,7 @@ INVENTORY_FILENAME = 'objects.inv'
 logger = logging.getLogger(__name__)
 return_codes_re = re.compile('[\r\n]+')
 
-DOMAIN_INDEX_TYPE = tuple[
+DOMAIN_INDEX_TYPE: TypeAlias = tuple[
     # Index name (e.g. py-modindex)
     str,
     # Index class
@@ -87,9 +96,9 @@ def _stable_hash(obj: Any) -> str:
     """
     if isinstance(obj, dict):
         obj = sorted(map(_stable_hash, obj.items()))
-    if isinstance(obj, (list, tuple, set, frozenset)):
+    if isinstance(obj, list | tuple | set | frozenset):
         obj = sorted(map(_stable_hash, obj))
-    elif isinstance(obj, (type, types.FunctionType)):
+    elif isinstance(obj, type | types.FunctionType):
         # The default repr() of functions includes the ID, which is not ideal.
         # We use the fully qualified name instead.
         obj = f'{obj.__module__}.{obj.__qualname__}'
@@ -395,7 +404,7 @@ class StandaloneHTMLBuilder(Builder):
             pass
 
         if self.templates:
-            template_mtime = self.templates.newest_template_mtime()
+            template_mtime = int(self.templates.newest_template_mtime() * 10**6)
         else:
             template_mtime = 0
         for docname in self.env.found_docs:
@@ -405,19 +414,19 @@ class StandaloneHTMLBuilder(Builder):
                 continue
             targetname = self.get_outfilename(docname)
             try:
-                targetmtime = path.getmtime(targetname)
+                targetmtime = _last_modified_time(targetname)
             except Exception:
                 targetmtime = 0
             try:
-                srcmtime = max(path.getmtime(self.env.doc2path(docname)), template_mtime)
+                srcmtime = max(_last_modified_time(self.env.doc2path(docname)), template_mtime)
                 if srcmtime > targetmtime:
                     logger.debug(
                         '[build target] targetname %r(%s), template(%s), docname %r(%s)',
                         targetname,
-                        _format_modified_time(targetmtime),
-                        _format_modified_time(template_mtime),
+                        _format_rfc3339_microseconds(targetmtime),
+                        _format_rfc3339_microseconds(template_mtime),
                         docname,
-                        _format_modified_time(path.getmtime(self.env.doc2path(docname))),
+                        _format_rfc3339_microseconds(_last_modified_time(self.env.doc2path(docname))),
                     )
                     yield docname
             except OSError:
@@ -609,7 +618,7 @@ class StandaloneHTMLBuilder(Builder):
         title = self.render_partial(title_node)['title'] if title_node else ''
 
         # Suffix for the document
-        source_suffix = self.env.doc2path(docname, False)[len(docname):]
+        source_suffix = str(self.env.doc2path(docname, False))[len(docname):]
 
         # the name for the copied source
         if self.config.html_copy_source:
@@ -734,7 +743,7 @@ class StandaloneHTMLBuilder(Builder):
                              'genindex-split.html')
             self.handle_page('genindex-all', genindexcontext,
                              'genindex.html')
-            for (key, entries), count in zip(genindex, indexcounts):
+            for (key, entries), count in zip(genindex, indexcounts, strict=True):
                 ctx = {'key': key, 'entries': entries, 'count': count,
                        'genindexentries': genindex}
                 self.handle_page('genindex-' + key, ctx,
@@ -755,17 +764,20 @@ class StandaloneHTMLBuilder(Builder):
     def copy_image_files(self) -> None:
         if self.images:
             stringify_func = ImageAdapter(self.app.env).get_original_image_uri
-            ensuredir(path.join(self.outdir, self.imagedir))
+            ensuredir(self.outdir / self.imagedir)
             for src in status_iterator(self.images, __('copying images... '), "brown",
                                        len(self.images), self.app.verbosity,
                                        stringify_func=stringify_func):
                 dest = self.images[src]
                 try:
-                    copyfile(path.join(self.srcdir, src),
-                             path.join(self.outdir, self.imagedir, dest))
+                    copyfile(
+                        self.srcdir / src,
+                        self.outdir / self.imagedir / dest,
+                        force=True,
+                    )
                 except Exception as err:
-                    logger.warning(__('cannot copy image file %r: %s'),
-                                   path.join(self.srcdir, src), err)
+                    logger.warning(__("cannot copy image file '%s': %s"),
+                                   self.srcdir / src, err)
 
     def copy_download_files(self) -> None:
         def to_relpath(f: str) -> str:
@@ -773,17 +785,17 @@ class StandaloneHTMLBuilder(Builder):
 
         # copy downloadable files
         if self.env.dlfiles:
-            ensuredir(path.join(self.outdir, '_downloads'))
+            ensuredir(self.outdir / '_downloads')
             for src in status_iterator(self.env.dlfiles, __('copying downloadable files... '),
                                        "brown", len(self.env.dlfiles), self.app.verbosity,
                                        stringify_func=to_relpath):
                 try:
-                    dest = path.join(self.outdir, '_downloads', self.env.dlfiles[src][1])
-                    ensuredir(path.dirname(dest))
-                    copyfile(path.join(self.srcdir, src), dest)
+                    dest = self.outdir / '_downloads' / self.env.dlfiles[src][1]
+                    ensuredir(dest.parent)
+                    copyfile(self.srcdir / src, dest, force=True)
                 except OSError as err:
                     logger.warning(__('cannot copy downloadable file %r: %s'),
-                                   path.join(self.srcdir, src), err)
+                                   self.srcdir / src, err)
 
     def create_pygments_style_file(self) -> None:
         """Create a style file for pygments."""
@@ -800,30 +812,45 @@ class StandaloneHTMLBuilder(Builder):
         """Copy a JavaScript file for translations."""
         jsfile = self._get_translations_js()
         if jsfile:
-            copyfile(jsfile, path.join(self.outdir, '_static', 'translations.js'))
+            copyfile(
+                jsfile,
+                self.outdir / '_static' / 'translations.js',
+                force=True,
+            )
 
     def copy_stemmer_js(self) -> None:
         """Copy a JavaScript file for stemmer."""
         if self.indexer is not None:
             if hasattr(self.indexer, 'get_js_stemmer_rawcodes'):
                 for jsfile in self.indexer.get_js_stemmer_rawcodes():
-                    copyfile(jsfile, path.join(self.outdir, '_static', path.basename(jsfile)))
+                    js_path = Path(jsfile)
+                    copyfile(
+                        js_path,
+                        self.outdir / '_static' / js_path.name,
+                        force=True,
+                    )
             else:
                 if js_stemmer_rawcode := self.indexer.get_js_stemmer_rawcode():
-                    copyfile(js_stemmer_rawcode,
-                             path.join(self.outdir, '_static', '_stemmer.js'))
+                    copyfile(
+                        js_stemmer_rawcode,
+                        self.outdir / '_static' / '_stemmer.js',
+                        force=True,
+                    )
 
     def copy_theme_static_files(self, context: dict[str, Any]) -> None:
         def onerror(filename: str, error: Exception) -> None:
-            logger.warning(__('Failed to copy a file in html_static_file: %s: %r'),
-                           filename, error)
+            msg = __("Failed to copy a file in the theme's 'static' directory: %s: %r")
+            logger.warning(msg, filename, error)
 
         if self.theme:
             for entry in reversed(self.theme.get_theme_dirs()):
-                copy_asset(path.join(entry, 'static'),
-                           path.join(self.outdir, '_static'),
-                           excluded=DOTFILES, context=context,
-                           renderer=self.templates, onerror=onerror)
+                copy_asset(
+                    Path(entry) / 'static',
+                    self.outdir / '_static',
+                    excluded=DOTFILES, context=context,
+                    renderer=self.templates, onerror=onerror,
+                    force=True,
+                )
 
     def copy_html_static_files(self, context: dict[str, Any]) -> None:
         def onerror(filename: str, error: Exception) -> None:
@@ -832,24 +859,36 @@ class StandaloneHTMLBuilder(Builder):
 
         excluded = Matcher([*self.config.exclude_patterns, '**/.*'])
         for entry in self.config.html_static_path:
-            copy_asset(path.join(self.confdir, entry),
-                       path.join(self.outdir, '_static'),
-                       excluded, context=context, renderer=self.templates, onerror=onerror)
+            copy_asset(
+                self.confdir / entry,
+                self.outdir / '_static',
+                excluded=excluded, context=context,
+                renderer=self.templates, onerror=onerror,
+                force=True,
+            )
 
     def copy_html_logo(self) -> None:
         if self.config.html_logo and not isurl(self.config.html_logo):
-            copy_asset(path.join(self.confdir, self.config.html_logo),
-                       path.join(self.outdir, '_static'))
+            source_path = self.confdir / self.config.html_logo
+            copyfile(
+                source_path,
+                self.outdir / '_static' / source_path.name,
+                force=True,
+            )
 
     def copy_html_favicon(self) -> None:
         if self.config.html_favicon and not isurl(self.config.html_favicon):
-            copy_asset(path.join(self.confdir, self.config.html_favicon),
-                       path.join(self.outdir, '_static'))
+            source_path = self.confdir / self.config.html_favicon
+            copyfile(
+                source_path,
+                self.outdir / '_static' / source_path.name,
+                force=True,
+            )
 
     def copy_static_files(self) -> None:
         try:
             with progress_message(__('copying static files')):
-                ensuredir(path.join(self.outdir, '_static'))
+                ensuredir(self.outdir / '_static')
 
                 # prepare context for templates
                 context = self.globalcontext.copy()
@@ -872,8 +911,12 @@ class StandaloneHTMLBuilder(Builder):
             with progress_message(__('copying extra files')):
                 excluded = Matcher(self.config.exclude_patterns)
                 for extra_path in self.config.html_extra_path:
-                    entry = path.join(self.confdir, extra_path)
-                    copy_asset(entry, self.outdir, excluded)
+                    copy_asset(
+                        self.confdir / extra_path,
+                        self.outdir,
+                        excluded=excluded,
+                        force=True,
+                    )
         except OSError as err:
             logger.warning(__('cannot copy extra file %r'), err)
 
@@ -940,7 +983,7 @@ class StandaloneHTMLBuilder(Builder):
     def index_page(self, pagename: str, doctree: nodes.document, title: str) -> None:
         # only index pages with title
         if self.indexer is not None and title:
-            filename = self.env.doc2path(pagename, base=False)
+            filename = str(self.env.doc2path(pagename, base=False))
             metadata = self.env.metadata.get(pagename, {})
             if 'no-search' in metadata or 'nosearch' in metadata:
                 self.indexer.feed(pagename, filename, '', new_document(''))
@@ -982,10 +1025,7 @@ class StandaloneHTMLBuilder(Builder):
                 matched = pattern
                 sidebars = pat_sidebars
 
-        # See error_on_html_sidebars_string_values.
-        # Replace with simple list coercion in Sphinx 8.0
-        # xref: RemovedInSphinx80Warning
-        ctx['sidebars'] = sidebars
+        ctx['sidebars'] = list(sidebars)
 
     # --------- these are overwritten by the serialization builder
 
@@ -1142,7 +1182,7 @@ class StandaloneHTMLBuilder(Builder):
             source_name = path.join(self.outdir, '_sources',
                                     os_path(ctx['sourcename']))
             ensuredir(path.dirname(source_name))
-            copyfile(self.env.doc2path(pagename), source_name)
+            copyfile(self.env.doc2path(pagename), source_name, force=True)
 
     def update_page_context(self, pagename: str, templatename: str,
                             ctx: dict[str, Any], event_arg: Any) -> None:
@@ -1191,12 +1231,6 @@ def convert_html_css_files(app: Sphinx, config: Config) -> None:
     config.html_css_files = html_css_files
 
 
-def _format_modified_time(timestamp: float) -> str:
-    """Return an RFC 3339 formatted string representing the given timestamp."""
-    seconds, fraction = divmod(timestamp, 1)
-    return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(seconds)) + f'.{fraction:.3f}'
-
-
 def convert_html_js_files(app: Sphinx, config: Config) -> None:
     """Convert string styled html_js_files to tuple styled one."""
     html_js_files: list[tuple[str, dict[str, str]]] = []
@@ -1299,10 +1333,7 @@ def error_on_html_sidebars_string_values(app: Sphinx, config: Config) -> None:
              "Change to `html_sidebars = %r`.")
     bad_patterns = ', '.join(map(repr, errors))
     fixed = config.html_sidebars | errors
-    logger.error(msg, bad_patterns, fixed)
-    # Enable hard error in next major version.
-    # xref: RemovedInSphinx80Warning
-    # raise ConfigError(msg % (bad_patterns, fixed))
+    raise ConfigError(msg % (bad_patterns, fixed))
 
 
 def error_on_html_4(_app: Sphinx, config: Config) -> None: