Sphinx 7.3.7__py3-none-any.whl → 7.4.1__py3-none-any.whl

sphinx/builders/html/__init__.py

@@ -115,7 +115,7 @@ class BuildInfo:
     """
 
     @classmethod
-    def load(cls: type[BuildInfo], f: IO) -> BuildInfo:
+    def load(cls: type[BuildInfo], f: IO[str]) -> BuildInfo:
         try:
             lines = f.readlines()
             assert lines[0].rstrip() == '# Sphinx build info version 1'
@@ -149,7 +149,7 @@ class BuildInfo:
         return (self.config_hash == other.config_hash and
                 self.tags_hash == other.tags_hash)
 
-    def dump(self, f: IO) -> None:
+    def dump(self, f: IO[str]) -> None:
         f.write('# Sphinx build info version 1\n'
                 '# This file hashes the configuration used when building these files.'
                 ' When it is not found, a full rebuild will be done.\n'
@@ -201,7 +201,9 @@ class StandaloneHTMLBuilder(Builder):
         self._js_files: list[_JavaScript] = []
 
         # Cached Publisher for writing doctrees to HTML
-        reader: Reader = docutils.readers.doctree.Reader(parser_name='restructuredtext')
+        reader: Reader[DocTreeInput] = docutils.readers.doctree.Reader(
+            parser_name='restructuredtext'
+        )
         pub = Publisher(
             reader=reader,
             parser=reader.parser,
@@ -209,11 +211,7 @@ class StandaloneHTMLBuilder(Builder):
             source_class=DocTreeInput,
             destination=StringOutput(encoding='unicode'),
         )
-        if docutils.__version_info__[:2] >= (0, 19):
-            pub.get_settings(output_encoding='unicode', traceback=True)
-        else:
-            op = pub.setup_option_parser(output_encoding='unicode', traceback=True)
-            pub.settings = op.get_default_values()
+        pub.get_settings(output_encoding='unicode', traceback=True)
         self._publisher = pub
 
     def init(self) -> None:
@@ -269,7 +267,7 @@ class StandaloneHTMLBuilder(Builder):
         else:
             yield 'default.css'
 
-    def get_theme_config(self) -> tuple[str, dict]:
+    def get_theme_config(self) -> tuple[str, dict[str, str | int | bool]]:
         return self.config.html_theme, self.config.html_theme_options
 
     def init_templates(self) -> None:
@@ -465,29 +463,31 @@ class StandaloneHTMLBuilder(Builder):
         # determine the additional indices to include
         self.domain_indices = []
         # html_domain_indices can be False/True or a list of index names
-        indices_config = self.config.html_domain_indices
-        if indices_config:
+        if indices_config := self.config.html_domain_indices:
+            if not isinstance(indices_config, bool):
+                check_names = True
+                indices_config = frozenset(indices_config)
+            else:
+                check_names = False
             for domain_name in sorted(self.env.domains):
                 domain: Domain = self.env.domains[domain_name]
-                for indexcls in domain.indices:
-                    indexname = f'{domain.name}-{indexcls.name}'
-                    if isinstance(indices_config, list):
-                        if indexname not in indices_config:
-                            continue
-                    content, collapse = indexcls(domain).generate()
+                for index_cls in domain.indices:
+                    index_name = f'{domain.name}-{index_cls.name}'
+                    if check_names and index_name not in indices_config:
+                        continue
+                    content, collapse = index_cls(domain).generate()
                     if content:
                         self.domain_indices.append(
-                            (indexname, indexcls, content, collapse))
+                            (index_name, index_cls, content, collapse))
 
         # format the "last updated on" string, only once is enough since it
         # typically doesn't include the time of day
-        self.last_updated: str | None
-        lufmt = self.config.html_last_updated_fmt
-        if lufmt is not None:
-            self.last_updated = format_date(lufmt or _('%b %d, %Y'),
-                                            language=self.config.language)
+        last_updated: str | None
+        if (lu_fmt := self.config.html_last_updated_fmt) is not None:
+            lu_fmt = lu_fmt or _('%b %d, %Y')
+            last_updated = format_date(lu_fmt, language=self.config.language)
         else:
-            self.last_updated = None
+            last_updated = None
 
         # If the logo or favicon are urls, keep them as-is, otherwise
         # strip the relative path as the files will be copied into _static.
@@ -526,7 +526,7 @@ class StandaloneHTMLBuilder(Builder):
             'project': self.config.project,
             'release': return_codes_re.sub('', self.config.release),
             'version': self.config.version,
-            'last_updated': self.last_updated,
+            'last_updated': last_updated,
             'copyright': self.config.copyright,
             'master_doc': self.config.root_doc,
             'root_doc': self.config.root_doc,
@@ -552,6 +552,7 @@ class StandaloneHTMLBuilder(Builder):
             'builder': self.name,
             'parents': [],
             'logo_url': logo,
+            'logo_alt': _('Logo of %s') % self.config.project,
             'favicon_url': favicon,
             'html5_doctype': True,
         }
@@ -824,7 +825,7 @@ class StandaloneHTMLBuilder(Builder):
                            excluded=DOTFILES, context=context,
                            renderer=self.templates, onerror=onerror)
 
-    def copy_html_static_files(self, context: dict) -> None:
+    def copy_html_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)
@@ -890,7 +891,7 @@ class StandaloneHTMLBuilder(Builder):
 
     def post_process_images(self, doctree: Node) -> None:
         """Pick the best candidate for an image and link down-scaled images to
-        their high res version.
+        their high resolution version.
         """
         super().post_process_images(doctree)
 
@@ -957,47 +958,48 @@ class StandaloneHTMLBuilder(Builder):
     def get_outfilename(self, pagename: str) -> str:
         return path.join(self.outdir, os_path(pagename) + self.out_suffix)
 
-    def add_sidebars(self, pagename: str, ctx: dict) -> None:
+    def add_sidebars(self, pagename: str, ctx: dict[str, Any]) -> None:
         def has_wildcard(pattern: str) -> bool:
             return any(char in pattern for char in '*?[')
 
         matched = None
-        customsidebar = None
 
         # default sidebars settings for selected theme
         sidebars = list(self.theme.sidebar_templates)
 
         # user sidebar settings
         html_sidebars = self.get_builder_config('sidebars', 'html')
-        for pattern, patsidebars in html_sidebars.items():
+        msg = __('page %s matches two patterns in html_sidebars: %r and %r')
+        for pattern, pat_sidebars in html_sidebars.items():
             if patmatch(pagename, pattern):
-                if matched:
-                    if has_wildcard(pattern):
-                        # warn if both patterns contain wildcards
-                        if has_wildcard(matched):
-                            logger.warning(__('page %s matches two patterns in '
-                                              'html_sidebars: %r and %r'),
-                                           pagename, matched, pattern)
-                        # else the already matched pattern is more specific
-                        # than the present one, because it contains no wildcard
-                        continue
+                if matched and has_wildcard(pattern):
+                    # warn if both patterns contain wildcards
+                    if has_wildcard(matched):
+                        logger.warning(msg, pagename, matched)
+                    # else the already matched pattern is more specific
+                    # than the present one, because it contains no wildcard
+                    continue
                 matched = pattern
-                sidebars = patsidebars
+                sidebars = pat_sidebars
 
         if len(sidebars) == 0:
             # keep defaults
             pass
 
-        ctx['sidebars'] = sidebars
-        ctx['customsidebar'] = customsidebar
+        ctx['sidebars'] = list(sidebars)
 
     # --------- these are overwritten by the serialization builder
 
     def get_target_uri(self, docname: str, typ: str | None = None) -> str:
         return quote(docname) + self.link_suffix
 
-    def handle_page(self, pagename: str, addctx: dict, templatename: str = 'page.html',
-                    outfilename: str | None = None, event_arg: Any = None) -> None:
+    def handle_page(
+        self, pagename: str,
+        addctx: dict[str, Any],
+        templatename: str = 'page.html',
+        outfilename: str | None = None,
+        event_arg: Any = None,
+    ) -> None:
         ctx = self.globalcontext.copy()
         # current_page_name is backwards compatibility
         ctx['pagename'] = ctx['current_page_name'] = pagename
@@ -1144,7 +1146,7 @@ class StandaloneHTMLBuilder(Builder):
             copyfile(self.env.doc2path(pagename), source_name)
 
     def update_page_context(self, pagename: str, templatename: str,
-                            ctx: dict, event_arg: Any) -> None:
+                            ctx: dict[str, Any], event_arg: Any) -> None:
         pass
 
     def handle_finish(self) -> None:
@@ -1175,7 +1177,7 @@ class StandaloneHTMLBuilder(Builder):
 
 def convert_html_css_files(app: Sphinx, config: Config) -> None:
     """Convert string styled html_css_files to tuple styled one."""
-    html_css_files: list[tuple[str, dict]] = []
+    html_css_files: list[tuple[str, dict[str, str]]] = []
     for entry in config.html_css_files:
         if isinstance(entry, str):
             html_css_files.append((entry, {}))
@@ -1187,7 +1189,7 @@ def convert_html_css_files(app: Sphinx, config: Config) -> None:
                 logger.warning(__('invalid css_file: %r, ignored'), entry)
                 continue
 
-    config.html_css_files = html_css_files  # type: ignore[attr-defined]
+    config.html_css_files = html_css_files
 
 
 def _format_modified_time(timestamp: float) -> str:
@@ -1198,7 +1200,7 @@ def _format_modified_time(timestamp: float) -> str:
 
 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]] = []
+    html_js_files: list[tuple[str, dict[str, str]]] = []
     for entry in config.html_js_files:
         if isinstance(entry, str):
             html_js_files.append((entry, {}))
@@ -1210,11 +1212,11 @@ def convert_html_js_files(app: Sphinx, config: Config) -> None:
                 logger.warning(__('invalid js_file: %r, ignored'), entry)
                 continue
 
-    config.html_js_files = html_js_files  # type: ignore[attr-defined]
+    config.html_js_files = html_js_files
 
 
 def setup_resource_paths(app: Sphinx, pagename: str, templatename: str,
-                         context: dict, doctree: Node) -> None:
+                         context: dict[str, Any], doctree: Node) -> None:
     """Set up relative resource paths."""
     pathto = context['pathto']
 
@@ -1273,7 +1275,7 @@ def validate_html_logo(app: Sphinx, config: Config) -> None:
             not path.isfile(path.join(app.confdir, config.html_logo)) and
             not isurl(config.html_logo)):
         logger.warning(__('logo file %r does not exist'), config.html_logo)
-        config.html_logo = None  # type: ignore[attr-defined]
+        config.html_logo = None
 
 
 def validate_html_favicon(app: Sphinx, config: Config) -> None:
@@ -1282,7 +1284,7 @@ def validate_html_favicon(app: Sphinx, config: Config) -> None:
             not path.isfile(path.join(app.confdir, config.html_favicon)) and
             not isurl(config.html_favicon)):
         logger.warning(__('favicon file %r does not exist'), config.html_favicon)
-        config.html_favicon = None  # type: ignore[attr-defined]
+        config.html_favicon = None
 
 
 def error_on_html_4(_app: Sphinx, config: Config) -> None:
@@ -1315,7 +1317,7 @@ def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_config_value('html_last_updated_fmt', None, 'html', str)
     app.add_config_value('html_sidebars', {}, 'html')
     app.add_config_value('html_additional_pages', {}, 'html')
-    app.add_config_value('html_domain_indices', True, 'html', list)
+    app.add_config_value('html_domain_indices', True, 'html', types={set, list})
     app.add_config_value('html_permalinks', True, 'html')
     app.add_config_value('html_permalinks_icon', '¶', 'html')
     app.add_config_value('html_use_index', True, 'html')

sphinx/builders/latex/__init__.py

@@ -417,7 +417,7 @@ class LaTeXBuilder(Builder):
         # use pre-1.6.x Makefile for make latexpdf on Windows
         if os.name == 'nt':
             staticdirname = path.join(package_dir, 'texinputs_win')
-            copy_asset_file(path.join(staticdirname, 'Makefile_t'),
+            copy_asset_file(path.join(staticdirname, 'Makefile.jinja'),
                             self.outdir, context=context)
 
     @progress_message(__('copying additional files'))
@@ -456,7 +456,7 @@ class LaTeXBuilder(Builder):
         if self.context['babel'] or self.context['polyglossia']:
             context['addtocaptions'] = r'\addto\captions%s' % self.babel.get_language()
 
-        filename = path.join(package_dir, 'templates', 'latex', 'sphinxmessages.sty_t')
+        filename = path.join(package_dir, 'templates', 'latex', 'sphinxmessages.sty.jinja')
         copy_asset_file(filename, self.outdir, context=context, renderer=LaTeXRenderer())
 
 
@@ -464,7 +464,7 @@ def validate_config_values(app: Sphinx, config: Config) -> None:
     for key in list(config.latex_elements):
         if key not in DEFAULT_SETTINGS:
             msg = __("Unknown configure key: latex_elements[%r], ignored.")
-            logger.warning(msg % (key,))
+            logger.warning(msg, key)
             config.latex_elements.pop(key)
 
 
@@ -472,7 +472,7 @@ def validate_latex_theme_options(app: Sphinx, config: Config) -> None:
     for key in list(config.latex_theme_options):
         if key not in Theme.UPDATABLE_KEYS:
             msg = __("Unknown theme option: latex_theme_options[%r], ignored.")
-            logger.warning(msg % (key,))
+            logger.warning(msg, key)
             config.latex_theme_options.pop(key)
 
 
@@ -539,7 +539,7 @@ def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_config_value('latex_use_xindy', default_latex_use_xindy, '', bool)
     app.add_config_value('latex_toplevel_sectioning', None, '',
                          ENUM(None, 'part', 'chapter', 'section'))
-    app.add_config_value('latex_domain_indices', True, '', list)
+    app.add_config_value('latex_domain_indices', True, '', types={set, list})
     app.add_config_value('latex_show_urls', 'no', '')
     app.add_config_value('latex_show_pagerefs', False, '')
     app.add_config_value('latex_elements', {}, '')

sphinx/builders/latex/constants.py

@@ -183,6 +183,11 @@ ADDITIONAL_SETTINGS: dict[Any, dict[str, Any]] = {
     },
 
     # special settings for latex_engine + language_code
+    ('lualatex', 'fr'): {
+        # use babel instead of polyglossia by default
+        'polyglossia':  '',
+        'babel':        '\\usepackage{babel}',
+    },
     ('xelatex', 'fr'): {
         # use babel instead of polyglossia by default
         'polyglossia':  '',

sphinx/builders/linkcheck.py

@@ -13,7 +13,7 @@ from os import path
 from queue import PriorityQueue, Queue
 from threading import Thread
 from typing import TYPE_CHECKING, NamedTuple, cast
-from urllib.parse import unquote, urlparse, urlsplit, urlunparse
+from urllib.parse import quote, unquote, urlparse, urlsplit, urlunparse
 
 from docutils import nodes
 from requests.exceptions import ConnectionError, HTTPError, SSLError, TooManyRedirects
@@ -102,9 +102,11 @@ class CheckExternalLinksBuilder(DummyBuilder):
     def process_result(self, result: CheckResult) -> None:
         filename = self.env.doc2path(result.docname, False)
 
-        linkstat = {'filename': filename, 'lineno': result.lineno,
-                    'status': result.status, 'code': result.code, 'uri': result.uri,
-                    'info': result.message}
+        linkstat: dict[str, str | int] = {
+            'filename': filename, 'lineno': result.lineno,
+            'status': result.status, 'code': result.code,
+            'uri': result.uri, 'info': result.message,
+        }
         self.write_linkstat(linkstat)
 
         if result.status == 'unchecked':
@@ -164,7 +166,7 @@ class CheckExternalLinksBuilder(DummyBuilder):
         else:
             raise ValueError('Unknown status %s.' % result.status)
 
-    def write_linkstat(self, data: dict) -> None:
+    def write_linkstat(self, data: dict[str, str | int]) -> None:
         self.json_outfile.write(json.dumps(data))
         self.json_outfile.write('\n')
 
@@ -178,41 +180,67 @@ class HyperlinkCollector(SphinxPostTransform):
     default_priority = 800
 
     def run(self, **kwargs: Any) -> None:
-        builder = cast(CheckExternalLinksBuilder, self.app.builder)
-        hyperlinks = builder.hyperlinks
-        docname = self.env.docname
+        for node in self.document.findall():
+            if uri := self.find_uri(node):
+                self._add_uri(uri, node)
+
+    def find_uri(self, node: nodes.Element) -> str | None:
+        """Find a URI for a given node.
 
+        This call can be used to retrieve a URI from a provided node. If no
+        URI exists for a provided node, this call will return ``None``.
+
+        This method can be useful for extension developers who wish to
+        easily inject hyperlinks into a builder by only needing to override
+        this method.
+
+        :param node: A node class
+        :returns: URI of the node
+        """
         # reference nodes
-        for refnode in self.document.findall(nodes.reference):
-            if 'refuri' in refnode:
-                uri = refnode['refuri']
-                _add_uri(self.app, uri, refnode, hyperlinks, docname)
+        if isinstance(node, nodes.reference):
+            if 'refuri' in node:
+                return node['refuri']
 
         # image nodes
-        for imgnode in self.document.findall(nodes.image):
-            uri = imgnode['candidates'].get('?')
+        if isinstance(node, nodes.image):
+            uri = node['candidates'].get('?')
             if uri and '://' in uri:
-                _add_uri(self.app, uri, imgnode, hyperlinks, docname)
+                return uri
 
         # raw nodes
-        for rawnode in self.document.findall(nodes.raw):
-            uri = rawnode.get('source')
+        if isinstance(node, nodes.raw):
+            uri = node.get('source')
             if uri and '://' in uri:
-                _add_uri(self.app, uri, rawnode, hyperlinks, docname)
+                return uri
+
+        return None
 
+    def _add_uri(self, uri: str, node: nodes.Element) -> None:
+        """Registers a node's URI into a builder's collection of hyperlinks.
 
-def _add_uri(app: Sphinx, uri: str, node: nodes.Element,
-             hyperlinks: dict[str, Hyperlink], docname: str) -> None:
-    if newuri := app.emit_firstresult('linkcheck-process-uri', uri):
-        uri = newuri
+        Provides the ability to register a URI value determined from a node
+        into the linkcheck's builder. URI's processed through this call can
+        be manipulated through a ``linkcheck-process-uri`` event before the
+        builder attempts to validate.
 
-    try:
-        lineno = get_node_line(node)
-    except ValueError:
-        lineno = -1
+        :param uri: URI to add
+        :param node: A node class where the URI was found
+        """
+        builder = cast(CheckExternalLinksBuilder, self.app.builder)
+        hyperlinks = builder.hyperlinks
+        docname = self.env.docname
+
+        if newuri := self.app.emit_firstresult('linkcheck-process-uri', uri):
+            uri = newuri
+
+        try:
+            lineno = get_node_line(node)
+        except ValueError:
+            lineno = -1
 
-    if uri not in hyperlinks:
-        hyperlinks[uri] = Hyperlink(uri, docname, app.env.doc2path(docname), lineno)
+        if uri not in hyperlinks:
+            hyperlinks[uri] = Hyperlink(uri, docname, self.env.doc2path(docname), lineno)
 
 
 class Hyperlink(NamedTuple):
@@ -390,9 +418,11 @@ class HyperlinkAvailabilityCheckWorker(Thread):
 
         return status, info, code
 
-    def _retrieval_methods(self,
-                           check_anchors: bool,
-                           anchor: str) -> Iterator[tuple[Callable, dict]]:
+    def _retrieval_methods(
+        self,
+        check_anchors: bool,
+        anchor: str,
+    ) -> Iterator[tuple[Callable[..., Response], dict[str, bool]]]:
         if not check_anchors or not anchor:
             yield self._session.head, {'allow_redirects': True}
         yield self._session.get, {'stream': True}
@@ -409,6 +439,7 @@ class HyperlinkAvailabilityCheckWorker(Thread):
                     if rex.match(req_url):
                         anchor = ''
                         break
+            anchor = unquote(anchor)
 
         # handle non-ASCII URIs
         try:
@@ -444,14 +475,18 @@ class HyperlinkAvailabilityCheckWorker(Thread):
                     _user_agent=self.user_agent,
                     _tls_info=(self.tls_verify, self.tls_cacerts),
                 ) as response:
-                    if (self.check_anchors and response.ok and anchor
-                            and not contains_anchor(response, anchor)):
-                        raise Exception(__(f'Anchor {anchor!r} not found'))
+                    if anchor and self.check_anchors and response.ok:
+                        try:
+                            found = contains_anchor(response, anchor)
+                        except UnicodeDecodeError:
+                            return 'ignored', 'unable to decode response content', 0
+                        if not found:
+                            return 'broken', __("Anchor '%s' not found") % quote(anchor), 0
 
                 # Copy data we need from the (closed) response
                 status_code = response.status_code
                 redirect_status_code = response.history[-1].status_code if response.history else None  # NoQA: E501
-                retry_after = response.headers.get('Retry-After')
+                retry_after = response.headers.get('Retry-After', '')
                 response_url = f'{response.url}'
                 response.raise_for_status()
                 del response
@@ -536,7 +571,7 @@ class HyperlinkAvailabilityCheckWorker(Thread):
         else:
             return 'redirected', response_url, 0
 
-    def limit_rate(self, response_url: str, retry_after: str) -> float | None:
+    def limit_rate(self, response_url: str, retry_after: str | None) -> float | None:
         delay = DEFAULT_DELAY
         next_check = None
         if retry_after:
@@ -592,7 +627,7 @@ def _get_request_headers(
 
 def contains_anchor(response: Response, anchor: str) -> bool:
     """Determine if an anchor is contained within an HTTP response."""
-    parser = AnchorCheckParser(unquote(anchor))
+    parser = AnchorCheckParser(anchor)
     # Read file in chunks. If we find a matching anchor, we break
     # the loop early in hopes not to have to download the whole thing.
     for chunk in response.iter_content(chunk_size=4096, decode_unicode=True):
@@ -681,7 +716,7 @@ def setup(app: Sphinx) -> ExtensionMetadata:
     # commonly used for dynamic pages
     app.add_config_value('linkcheck_anchors_ignore', ['^!'], '')
     app.add_config_value('linkcheck_anchors_ignore_for_url', (), '', (tuple, list))
-    app.add_config_value('linkcheck_rate_limit_timeout', 300.0, '')
+    app.add_config_value('linkcheck_rate_limit_timeout', 300.0, '', (int, float))
     app.add_config_value('linkcheck_allow_unauthorized', True, '')
     app.add_config_value('linkcheck_report_timeouts_as_broken', True, '', bool)
 

sphinx/builders/texinfo.py

@@ -221,7 +221,7 @@ def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_config_value('texinfo_documents', default_texinfo_documents, '')
     app.add_config_value('texinfo_appendices', [], '')
     app.add_config_value('texinfo_elements', {}, '')
-    app.add_config_value('texinfo_domain_indices', True, '', list)
+    app.add_config_value('texinfo_domain_indices', True, '', types={set, list})
     app.add_config_value('texinfo_show_urls', 'footnote', '')
     app.add_config_value('texinfo_no_detailmenu', False, '')
     app.add_config_value('texinfo_cross_references', True, '')

sphinx/cmd/build.py

@@ -179,7 +179,7 @@ files can be built by specifying individual filenames.
                        dest='tags', default=[],
                        help=__('define tag: include "only" blocks with TAG'))
     group.add_argument('--nitpicky', '-n', action='store_true', dest='nitpicky',
-                       help=__('nit-picky mode: warn about all missing references'))
+                       help=__('nitpicky mode: warn about all missing references'))
 
     group = parser.add_argument_group(__('console output options'))
     group.add_argument('--verbose', '-v', action='count', dest='verbosity',

sphinx/cmd/quickstart.py

@@ -372,32 +372,32 @@ def generate(
             if 'quiet' not in d:
                 print(__('File %s already exists, skipping.') % fpath)
 
-    conf_path = os.path.join(templatedir, 'conf.py_t') if templatedir else None
+    conf_path = os.path.join(templatedir, 'conf.py.jinja') if templatedir else None
     if not conf_path or not path.isfile(conf_path):
-        conf_path = os.path.join(package_dir, 'templates', 'quickstart', 'conf.py_t')
+        conf_path = os.path.join(package_dir, 'templates', 'quickstart', 'conf.py.jinja')
     with open(conf_path, encoding="utf-8") as f:
         conf_text = f.read()
 
     write_file(path.join(srcdir, 'conf.py'), template.render_string(conf_text, d))
 
     masterfile = path.join(srcdir, d['master'] + d['suffix'])
-    if template._has_custom_template('quickstart/master_doc.rst_t'):
-        msg = ('A custom template `master_doc.rst_t` found. It has been renamed to '
-               '`root_doc.rst_t`.  Please rename it on your project too.')
+    if template._has_custom_template('quickstart/master_doc.rst.jinja'):
+        msg = ('A custom template `master_doc.rst.jinja` found. It has been renamed to '
+               '`root_doc.rst.jinja`.  Please rename it on your project too.')
         print(colorize('red', msg))
-        write_file(masterfile, template.render('quickstart/master_doc.rst_t', d))
+        write_file(masterfile, template.render('quickstart/master_doc.rst.jinja', d))
     else:
-        write_file(masterfile, template.render('quickstart/root_doc.rst_t', d))
+        write_file(masterfile, template.render('quickstart/root_doc.rst.jinja', d))
 
     if d.get('make_mode'):
-        makefile_template = 'quickstart/Makefile.new_t'
-        batchfile_template = 'quickstart/make.bat.new_t'
+        makefile_template = 'quickstart/Makefile.new.jinja'
+        batchfile_template = 'quickstart/make.bat.new.jinja'
     else:
         # xref RemovedInSphinx80Warning
         msg = "Support for '--no-use-make-mode' will be removed in Sphinx 8."
         print(colorize('red', msg))
-        makefile_template = 'quickstart/Makefile_t'
-        batchfile_template = 'quickstart/make.bat_t'
+        makefile_template = 'quickstart/Makefile.jinja'
+        batchfile_template = 'quickstart/make.bat.jinja'
 
     if d['makefile'] is True:
         d['rsrcdir'] = 'source' if d['sep'] else '.'