Sphinx 8.0.1__py3-none-any.whl → 8.1.0__py3-none-any.whl

sphinx/roles.py

@@ -88,15 +88,15 @@ class XRefRole(ReferenceRole):
 
     def update_title_and_target(self, title: str, target: str) -> tuple[str, str]:
         if not self.has_explicit_title:
-            if title.endswith('()'):
-                # remove parentheses
-                title = title[:-2]
             if self.config.add_function_parentheses:
-                # add them back to all occurrences if configured
-                title += '()'
-        # remove parentheses from the target too
-        if target.endswith('()'):
-            target = target[:-2]
+                if not title.endswith('()'):
+                    # add parentheses to the title
+                    title += '()'
+            else:
+                # remove parentheses
+                title = title.removesuffix('()')
+        # remove parentheses from the target
+        target = target.removesuffix('()')
         return title, target
 
     def run(self) -> tuple[list[Node], list[system_message]]:
@@ -167,7 +167,11 @@ class XRefRole(ReferenceRole):
         return title, ws_re.sub(' ', target)
 
     def result_nodes(
-        self, document: nodes.document, env: BuildEnvironment, node: Element, is_ref: bool
+        self,
+        document: nodes.document,
+        env: BuildEnvironment,
+        node: Element,
+        is_ref: bool,
     ) -> tuple[list[Node], list[system_message]]:
         """Called before returning the finished nodes.  *node* is the reference
         node if one was created (*is_ref* is then true), else the content node.
@@ -192,6 +196,94 @@ class AnyXRefRole(XRefRole):
         return result
 
 
+class CVE(ReferenceRole):
+    def run(self) -> tuple[list[Node], list[system_message]]:
+        target_id = f'index-{self.env.new_serialno("index")}'
+        entries = [
+            (
+                'single',
+                _('Common Vulnerabilities and Exposures; CVE %s') % self.target,
+                target_id,
+                '',
+                None,
+            )
+        ]
+
+        index = addnodes.index(entries=entries)
+        target = nodes.target('', '', ids=[target_id])
+        self.inliner.document.note_explicit_target(target)
+
+        try:
+            refuri = self.build_uri()
+            reference = nodes.reference(
+                '', '', internal=False, refuri=refuri, classes=['cve']
+            )
+            if self.has_explicit_title:
+                reference += nodes.strong(self.title, self.title)
+            else:
+                title = f'CVE {self.title}'
+                reference += nodes.strong(title, title)
+        except ValueError:
+            msg = self.inliner.reporter.error(
+                __('invalid CVE number %s') % self.target, line=self.lineno
+            )
+            prb = self.inliner.problematic(self.rawtext, self.rawtext, msg)
+            return [prb], [msg]
+
+        return [index, target, reference], []
+
+    def build_uri(self) -> str:
+        base_url = self.inliner.document.settings.cve_base_url
+        ret = self.target.split('#', 1)
+        if len(ret) == 2:
+            return f'{base_url}{ret[0]}#{ret[1]}'
+        return f'{base_url}{ret[0]}'
+
+
+class CWE(ReferenceRole):
+    def run(self) -> tuple[list[Node], list[system_message]]:
+        target_id = f'index-{self.env.new_serialno("index")}'
+        entries = [
+            (
+                'single',
+                _('Common Weakness Enumeration; CWE %s') % self.target,
+                target_id,
+                '',
+                None,
+            )
+        ]
+
+        index = addnodes.index(entries=entries)
+        target = nodes.target('', '', ids=[target_id])
+        self.inliner.document.note_explicit_target(target)
+
+        try:
+            refuri = self.build_uri()
+            reference = nodes.reference(
+                '', '', internal=False, refuri=refuri, classes=['cwe']
+            )
+            if self.has_explicit_title:
+                reference += nodes.strong(self.title, self.title)
+            else:
+                title = f'CWE {self.title}'
+                reference += nodes.strong(title, title)
+        except ValueError:
+            msg = self.inliner.reporter.error(
+                __('invalid CWE number %s') % self.target, line=self.lineno
+            )
+            prb = self.inliner.problematic(self.rawtext, self.rawtext, msg)
+            return [prb], [msg]
+
+        return [index, target, reference], []
+
+    def build_uri(self) -> str:
+        base_url = self.inliner.document.settings.cwe_base_url
+        ret = self.target.split('#', 1)
+        if len(ret) == 2:
+            return f'{base_url}{int(ret[0])}.html#{ret[1]}'
+        return f'{base_url}{int(ret[0])}.html'
+
+
 class PEP(ReferenceRole):
     def run(self) -> tuple[list[Node], list[system_message]]:
         target_id = 'index-%s' % self.env.new_serialno('index')
@@ -211,7 +303,9 @@ class PEP(ReferenceRole):
 
         try:
             refuri = self.build_uri()
-            reference = nodes.reference('', '', internal=False, refuri=refuri, classes=['pep'])
+            reference = nodes.reference(
+                '', '', internal=False, refuri=refuri, classes=['pep']
+            )
             if self.has_explicit_title:
                 reference += nodes.strong(self.title, self.title)
             else:
@@ -238,7 +332,8 @@ class PEP(ReferenceRole):
 class RFC(ReferenceRole):
     def run(self) -> tuple[list[Node], list[system_message]]:
         target_id = 'index-%s' % self.env.new_serialno('index')
-        entries = [('single', 'RFC; RFC %s' % self.target, target_id, '', None)]
+        formatted_target = _format_rfc_target(self.target)
+        entries = [('single', f'RFC; {formatted_target}', target_id, '', None)]
 
         index = addnodes.index(entries=entries)
         target = nodes.target('', '', ids=[target_id])
@@ -246,11 +341,13 @@ class RFC(ReferenceRole):
 
         try:
             refuri = self.build_uri()
-            reference = nodes.reference('', '', internal=False, refuri=refuri, classes=['rfc'])
+            reference = nodes.reference(
+                '', '', internal=False, refuri=refuri, classes=['rfc']
+            )
             if self.has_explicit_title:
                 reference += nodes.strong(self.title, self.title)
             else:
-                title = 'RFC ' + self.title
+                title = formatted_target
                 reference += nodes.strong(title, title)
         except ValueError:
             msg = self.inliner.reporter.error(
@@ -270,6 +367,24 @@ class RFC(ReferenceRole):
             return base_url + self.inliner.rfc_url % int(ret[0])
 
 
+def _format_rfc_target(target: str, /) -> str:
+    """
+    Takes an RFC number with an optional anchor (like ``123#section-2.5.3``)
+    and attempts to produce a human-friendly title for it.
+
+    We have a set of known anchors that we format nicely,
+    everything else we leave alone.
+    """
+    number, _, anchor = target.partition('#')
+    if anchor:
+        first, _, remaining = anchor.partition('-')
+        if first in {'appendix', 'page', 'section'}:
+            if remaining:
+                return f'RFC {number} {first.title()} {remaining}'
+            return f'RFC {number} {first.title()}'
+    return f'RFC {target}'
+
+
 class GUILabel(SphinxRole):
     amp_re = re.compile(r'(?<!&)&(?![&\s])')
 
@@ -446,12 +561,17 @@ specific_docroles: dict[str, RoleFunction] = {
     'download': XRefRole(nodeclass=addnodes.download_reference),
     # links to anything
     'any': AnyXRefRole(warn_dangling=True),
+    # external links
+    'cve': CVE(),
+    'cwe': CWE(),
     'pep': PEP(),
     'rfc': RFC(),
+    # emphasised things
     'guilabel': GUILabel(),
     'menuselection': MenuSelection(),
     'file': EmphasizedLiteral(),
     'samp': EmphasizedLiteral(),
+    # other
     'abbr': Abbreviation(),
     'manpage': Manpage(),
 }

sphinx/search/__init__.py

@@ -1,4 +1,5 @@
 """Create a full-text search index for offline search."""
+
 from __future__ import annotations
 
 import dataclasses
@@ -15,11 +16,12 @@ from docutils import nodes
 from docutils.nodes import Element, Node
 
 from sphinx import addnodes, package_dir
-from sphinx.environment import BuildEnvironment
 from sphinx.util.index_entries import split_index_msg
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Callable, Iterable
+
+    from sphinx.environment import BuildEnvironment
 
 
 class SearchLanguage:
@@ -52,10 +54,11 @@ class SearchLanguage:
        This class is used to preprocess search word which Sphinx HTML readers
        type, before searching index. Default implementation does nothing.
     """
+
     lang: str = ''
     language_name: str = ''
     stopwords: set[str] = set()
-    js_splitter_code: str = ""
+    js_splitter_code: str = ''
     js_stemmer_rawcode: str = ''
     js_stemmer_code = """
 /**
@@ -105,16 +108,14 @@ var Stemmer = function() {
         Return true if the target word should be registered in the search index.
         This method is called after stemming.
         """
-        return (
-            len(word) == 0 or not (
-                ((len(word) < 3) and (12353 < ord(word[0]) < 12436)) or
-                (ord(word[0]) < 256 and (
-                    word in self.stopwords
-                ))))
+        return len(word) == 0 or not (
+            ((len(word) < 3) and (12353 < ord(word[0]) < 12436))
+            or (ord(word[0]) < 256 and (word in self.stopwords))
+        )
 
 
 # SearchEnglish imported after SearchLanguage is defined due to circular import
-from sphinx.search.en import SearchEnglish
+from sphinx.search.en import SearchEnglish  # NoQA: E402
 
 
 def parse_stop_word(source: str) -> set[str]:
@@ -165,10 +166,10 @@ class _JavaScriptIndex:
         return self.PREFIX + json.dumps(data, sort_keys=True) + self.SUFFIX
 
     def loads(self, s: str) -> Any:
-        data = s[len(self.PREFIX):-len(self.SUFFIX)]
-        if not data or not s.startswith(self.PREFIX) or not \
-           s.endswith(self.SUFFIX):
-            raise ValueError('invalid data')
+        data = s[len(self.PREFIX) : -len(self.SUFFIX)]
+        if not data or not s.startswith(self.PREFIX) or not s.endswith(self.SUFFIX):
+            msg = 'invalid data'
+            raise ValueError(msg)
         return json.loads(data)
 
     def dump(self, data: Any, f: IO[str]) -> None:
@@ -187,9 +188,8 @@ def _is_meta_keywords(
 ) -> bool:
     if node.get('name') == 'keywords':
         meta_lang = node.get('lang')
-        if meta_lang is None:  # lang not specified
-            return True
-        elif meta_lang == lang:  # matched to html_search_language
+        if meta_lang is None or meta_lang == lang:
+            # lang not specified or matched to html_search_language
             return True
 
     return False
@@ -222,8 +222,18 @@ class WordCollector(nodes.NodeVisitor):
                 # Some people might put content in raw HTML that should be searched,
                 # so we just amateurishly strip HTML tags and index the remaining
                 # content
-                nodetext = re.sub(r'<style.*?</style>', '', node.astext(), flags=re.IGNORECASE|re.DOTALL)
-                nodetext = re.sub(r'<script.*?</script>', '', nodetext, flags=re.IGNORECASE|re.DOTALL)
+                nodetext = re.sub(
+                    r'<style.*?</style>',
+                    '',
+                    node.astext(),
+                    flags=re.IGNORECASE | re.DOTALL,
+                )
+                nodetext = re.sub(
+                    r'<script.*?</script>',
+                    '',
+                    nodetext,
+                    flags=re.IGNORECASE | re.DOTALL,
+                )
                 nodetext = re.sub(r'<[^<]+?>', '', nodetext)
                 self.found_words.extend(self.lang.split(nodetext))
             raise nodes.SkipNode
@@ -245,12 +255,15 @@ class IndexBuilder:
     Helper class that creates a search index based on the doctrees
     passed to the `feed` method.
     """
+
     formats = {
-        'json':     json,
-        'pickle':   pickle
+        'json': json,
+        'pickle': pickle,
     }
 
-    def __init__(self, env: BuildEnvironment, lang: str, options: dict[str, str], scoring: str) -> None:
+    def __init__(
+        self, env: BuildEnvironment, lang: str, options: dict[str, str], scoring: str
+    ) -> None:
         self.env = env
         # docname -> title
         self._titles: dict[str, str | None] = env._search_index_titles
@@ -261,9 +274,13 @@ class IndexBuilder:
         # stemmed words in titles -> set(docname)
         self._title_mapping: dict[str, set[str]] = env._search_index_title_mapping
         # docname -> all titles in document
-        self._all_titles: dict[str, list[tuple[str, str | None]]] = env._search_index_all_titles
+        self._all_titles: dict[str, list[tuple[str, str | None]]] = (
+            env._search_index_all_titles
+        )
         # docname -> list(index entry)
-        self._index_entries: dict[str, list[tuple[str, str, str]]] = env._search_index_index_entries
+        self._index_entries: dict[str, list[tuple[str, str, str]]] = (
+            env._search_index_index_entries
+        )
         # objtype -> index
         self._objtypes: dict[tuple[str, str], int] = env._search_index_objtypes
         # objtype index -> (domain, type, objname (localized))
@@ -290,7 +307,7 @@ class IndexBuilder:
                 self.js_scorer_code = fp.read().decode()
         else:
             self.js_scorer_code = ''
-        self.js_splitter_code = ""
+        self.js_splitter_code = ''
 
     def load(self, stream: IO, format: Any) -> None:
         """Reconstruct from frozen data."""
@@ -298,15 +315,15 @@ class IndexBuilder:
             format = self.formats[format]
         frozen = format.load(stream)
         # if an old index is present, we treat it as not existing.
-        if not isinstance(frozen, dict) or \
-           frozen.get('envversion') != self.env.version:
-            raise ValueError('old format')
+        if not isinstance(frozen, dict) or frozen.get('envversion') != self.env.version:
+            msg = 'old format'
+            raise ValueError(msg)
         index2fn = frozen['docnames']
-        self._filenames = dict(zip(index2fn, frozen['filenames']))
-        self._titles = dict(zip(index2fn, frozen['titles']))
+        self._filenames = dict(zip(index2fn, frozen['filenames'], strict=True))
+        self._titles = dict(zip(index2fn, frozen['titles'], strict=True))
         self._all_titles = {}
 
-        for docname in self._titles.keys():
+        for docname in self._titles:
             self._all_titles[docname] = []
         for title, doc_tuples in frozen['alltitles'].items():
             for doc, titleid in doc_tuples:
@@ -331,14 +348,15 @@ class IndexBuilder:
             format = self.formats[format]
         format.dump(self.freeze(), stream)
 
-    def get_objects(self, fn2index: dict[str, int]
-                    ) -> dict[str, list[tuple[int, int, int, str, str]]]:
+    def get_objects(
+        self, fn2index: dict[str, int]
+    ) -> dict[str, list[tuple[int, int, int, str, str]]]:
         rv: dict[str, list[tuple[int, int, int, str, str]]] = {}
         otypes = self._objtypes
         onames = self._objnames
-        for domainname, domain in sorted(self.env.domains.items()):
-            for fullname, dispname, type, docname, anchor, prio in \
-                    sorted(domain.get_objects()):
+        for domain in self.env.domains.sorted():
+            sorted_objects = sorted(domain.get_objects())
+            for fullname, dispname, type, docname, anchor, prio in sorted_objects:
                 if docname not in fn2index:
                     continue
                 if prio < 0:
@@ -348,17 +366,20 @@ class IndexBuilder:
                 prefix, _, name = dispname.rpartition('.')
                 plist = rv.setdefault(prefix, [])
                 try:
-                    typeindex = otypes[domainname, type]
+                    typeindex = otypes[domain.name, type]
                 except KeyError:
                     typeindex = len(otypes)
-                    otypes[domainname, type] = typeindex
+                    otypes[domain.name, type] = typeindex
                     otype = domain.object_types.get(type)
                     if otype:
                         # use str() to fire translation proxies
-                        onames[typeindex] = (domainname, type,
-                                             str(domain.get_type_name(otype)))
+                        onames[typeindex] = (
+                            domain.name,
+                            type,
+                            str(domain.get_type_name(otype)),
+                        )
                     else:
-                        onames[typeindex] = (domainname, type, type)
+                        onames[typeindex] = (domain.name, type, type)
                 if anchor == fullname:
                     shortanchor = ''
                 elif anchor == type + '-' + fullname:
@@ -368,7 +389,9 @@ class IndexBuilder:
                 plist.append((fn2index[docname], typeindex, prio, shortanchor, name))
         return rv
 
-    def get_terms(self, fn2index: dict[str, int]) -> tuple[dict[str, list[int] | int], dict[str, list[int] | int]]:
+    def get_terms(
+        self, fn2index: dict[str, int]
+    ) -> tuple[dict[str, list[int] | int], dict[str, list[int] | int]]:
         """
         Return a mapping of document and title terms to their corresponding sorted document IDs.
 
@@ -377,10 +400,10 @@ class IndexBuilder:
         of integers.
         """
         rvs: tuple[dict[str, list[int] | int], dict[str, list[int] | int]] = ({}, {})
-        for rv, mapping in zip(rvs, (self._mapping, self._title_mapping)):
+        for rv, mapping in zip(rvs, (self._mapping, self._title_mapping), strict=True):
             for k, v in mapping.items():
                 if len(v) == 1:
-                    fn, = v
+                    (fn,) = v
                     if fn in fn2index:
                         rv[k] = fn2index[fn]
                 else:
@@ -389,7 +412,7 @@ class IndexBuilder:
 
     def freeze(self) -> dict[str, Any]:
         """Create a usable data structure for serializing."""
-        docnames, titles = zip(*sorted(self._titles.items()))
+        docnames, titles = zip(*sorted(self._titles.items()), strict=True)
         filenames = [self._filenames.get(docname) for docname in docnames]
         fn2index = {f: i for (i, f) in enumerate(docnames)}
         terms, title_terms = self.get_terms(fn2index)
@@ -406,15 +429,28 @@ class IndexBuilder:
         index_entries: dict[str, list[tuple[int, str, bool]]] = {}
         for docname, entries in self._index_entries.items():
             for entry, entry_id, main_entry in entries:
-                index_entries.setdefault(entry.lower(), []).append((fn2index[docname], entry_id, main_entry == "main"))
+                index_entries.setdefault(entry.lower(), []).append((
+                    fn2index[docname],
+                    entry_id,
+                    main_entry == 'main',
+                ))
 
-        return dict(docnames=docnames, filenames=filenames, titles=titles, terms=terms,
-                    objects=objects, objtypes=objtypes, objnames=objnames,
-                    titleterms=title_terms, envversion=self.env.version,
-                    alltitles=alltitles, indexentries=index_entries)
+        return {
+            'docnames': docnames,
+            'filenames': filenames,
+            'titles': titles,
+            'terms': terms,
+            'objects': objects,
+            'objtypes': objtypes,
+            'objnames': objnames,
+            'titleterms': title_terms,
+            'envversion': self.env.version,
+            'alltitles': alltitles,
+            'indexentries': index_entries,
+        }
 
     def label(self) -> str:
-        return f"{self.lang.language_name} (code: {self.lang.lang})"
+        return f'{self.lang.language_name} (code: {self.lang.lang})'
 
     def prune(self, docnames: Iterable[str]) -> None:
         """Remove data for all docnames not in the list."""
@@ -434,7 +470,9 @@ class IndexBuilder:
         for wordnames in self._title_mapping.values():
             wordnames.intersection_update(docnames)
 
-    def feed(self, docname: str, filename: str, title: str, doctree: nodes.document) -> None:
+    def feed(
+        self, docname: str, filename: str, title: str, doctree: nodes.document
+    ) -> None:
         """Feed a doctree to the index."""
         self._titles[docname] = title
         self._filenames[docname] = filename
@@ -487,40 +525,12 @@ class IndexBuilder:
         self._index_entries[docname] = sorted(_index_entries)
 
     def _word_collector(self, doctree: nodes.document) -> WordStore:
-        def _visit_nodes(node: nodes.Node) -> None:
-            if isinstance(node, nodes.comment):
-                return
-            elif isinstance(node, nodes.raw):
-                if 'html' in node.get('format', '').split():
-                    # Some people might put content in raw HTML that should be searched,
-                    # so we just amateurishly strip HTML tags and index the remaining
-                    # content
-                    nodetext = re.sub(r'<style.*?</style>', '', node.astext(),
-                                      flags=re.IGNORECASE | re.DOTALL)
-                    nodetext = re.sub(r'<script.*?</script>', '', nodetext,
-                                      flags=re.IGNORECASE | re.DOTALL)
-                    nodetext = re.sub(r'<[^<]+?>', '', nodetext)
-                    word_store.words.extend(split(nodetext))
-                return
-            elif (isinstance(node, nodes.meta)
-                  and _is_meta_keywords(node, language)):
-                keywords = [keyword.strip() for keyword in node['content'].split(',')]
-                word_store.words.extend(keywords)
-            elif isinstance(node, nodes.Text):
-                word_store.words.extend(split(node.astext()))
-            elif isinstance(node, nodes.title):
-                title, is_main_title = node.astext(), len(word_store.titles) == 0
-                ids = node.parent['ids']
-                title_node_id = None if is_main_title else ids[0] if ids else None
-                word_store.titles.append((title, title_node_id))
-                word_store.title_words.extend(split(title))
-            for child in node.children:
-                _visit_nodes(child)
-
         word_store = WordStore()
         split = self.lang.split
         language = self.lang.lang
-        _visit_nodes(doctree)
+        _feed_visit_nodes(
+            doctree, word_store=word_store, split=split, language=language
+        )
         return word_store
 
     def context_for_searchtool(self) -> dict[str, Any]:
@@ -553,11 +563,60 @@ class IndexBuilder:
         """Returns JS code that will be inserted into language_data.js."""
         if self.lang.js_stemmer_rawcode:
             js_dir = path.join(package_dir, 'search', 'minified-js')
-            with open(path.join(js_dir, 'base-stemmer.js'), encoding='utf-8') as js_file:
+            with open(
+                path.join(js_dir, 'base-stemmer.js'), encoding='utf-8'
+            ) as js_file:
                 base_js = js_file.read()
-            with open(path.join(js_dir, self.lang.js_stemmer_rawcode), encoding='utf-8') as js_file:
+            with open(
+                path.join(js_dir, self.lang.js_stemmer_rawcode), encoding='utf-8'
+            ) as js_file:
                 language_js = js_file.read()
-            return ('%s\n%s\nStemmer = %sStemmer;' %
-                    (base_js, language_js, self.lang.language_name))
+            return (
+                f'{base_js}\n{language_js}\nStemmer = {self.lang.language_name}Stemmer;'
+            )
         else:
             return self.lang.js_stemmer_code
+
+
+def _feed_visit_nodes(
+    node: nodes.Node,
+    *,
+    word_store: WordStore,
+    split: Callable[[str], list[str]],
+    language: str,
+) -> None:
+    if isinstance(node, nodes.comment):
+        return
+    elif isinstance(node, nodes.raw):
+        if 'html' in node.get('format', '').split():
+            # Some people might put content in raw HTML that should be searched,
+            # so we just amateurishly strip HTML tags and index the remaining
+            # content
+            nodetext = re.sub(
+                r'<style.*?</style>',
+                '',
+                node.astext(),
+                flags=re.IGNORECASE | re.DOTALL,
+            )
+            nodetext = re.sub(
+                r'<script.*?</script>',
+                '',
+                nodetext,
+                flags=re.IGNORECASE | re.DOTALL,
+            )
+            nodetext = re.sub(r'<[^<]+?>', '', nodetext)
+            word_store.words.extend(split(nodetext))
+        return
+    elif isinstance(node, nodes.meta) and _is_meta_keywords(node, language):
+        keywords = [keyword.strip() for keyword in node['content'].split(',')]
+        word_store.words.extend(keywords)
+    elif isinstance(node, nodes.Text):
+        word_store.words.extend(split(node.astext()))
+    elif isinstance(node, nodes.title):
+        title, is_main_title = node.astext(), len(word_store.titles) == 0
+        ids = node.parent['ids']
+        title_node_id = None if is_main_title else ids[0] if ids else None
+        word_store.titles.append((title, title_node_id))
+        word_store.title_words.extend(split(title))
+    for child in node.children:
+        _feed_visit_nodes(child, word_store=word_store, split=split, language=language)

sphinx/search/da.py

@@ -2,13 +2,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
-
 import snowballstemmer
 
 from sphinx.search import SearchLanguage, parse_stop_word
 
-danish_stopwords = parse_stop_word('''
+danish_stopwords = parse_stop_word("""
 | source: https://snowball.tartarus.org/algorithms/danish/stop.txt
 og           | and
 i            | in
@@ -104,7 +102,7 @@ været        | be
 thi          | for (conj)
 jer          | you
 sådan        | such, like this/like that
-''')
+""")
 
 
 class SearchDanish(SearchLanguage):

sphinx/search/de.py

@@ -2,13 +2,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
-
 import snowballstemmer
 
 from sphinx.search import SearchLanguage, parse_stop_word
 
-german_stopwords = parse_stop_word('''
+german_stopwords = parse_stop_word("""
 |source: https://snowball.tartarus.org/algorithms/german/stop.txt
 aber           |  but
 
@@ -287,7 +285,7 @@ zum            |  zu + dem
 zur            |  zu + der
 zwar           |  indeed
 zwischen       |  between
-''')
+""")
 
 
 class SearchGerman(SearchLanguage):

sphinx/search/en.py

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
-
 import snowballstemmer
 
 from sphinx.search import SearchLanguage
 
-english_stopwords = set("""
+english_stopwords = set(
+    """
 a  and  are  as  at
 be  but  by
 for
@@ -18,7 +17,8 @@ of  on  or
 such
 that  the  their  then  there  these  they  this  to
 was  will  with
-""".split())
+""".split()
+)
 
 js_porter_stemmer = """
 /**