Sphinx 7.3.6__py3-none-any.whl → 7.4.0__py3-none-any.whl

sphinx/themes/agogo/layout.html

@@ -15,14 +15,14 @@
       <div class="header">
         {%- if logo_url %}
           <p class="logo"><a href="{{ pathto(root_doc)|e }}">
-            <img class="logo" src="{{ logo_url|e }}" alt="Logo"/>
+            <img class="logo" src="{{ logo_url|e }}" alt="{{ logo_alt|e }}"/>
           </a></p>
         {%- endif %}
         {%- block headertitle %}
         <div class="headertitle"><a
           href="{{ pathto(root_doc)|e }}">{{ shorttitle|e }}</a></div>
         {%- endblock %}
-        <div class="rel" role="navigation" aria-label="related navigation">
+        <div class="rel" role="navigation" aria-label="Related">
           {%- for rellink in rellinks|reverse %}
           <a href="{{ pathto(rellink[0])|e }}" title="{{ rellink[1]|striptags|e }}"
              {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
@@ -76,7 +76,7 @@
     <div class="footer-wrapper">
       <div class="footer">
         <div class="left">
-          <div role="navigation" aria-label="related navigation">
+          <div role="navigation" aria-label="Related">
             {%- for rellink in rellinks|reverse %}
             <a href="{{ pathto(rellink[0])|e }}" title="{{ rellink[1]|striptags|e }}"
               {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>

sphinx/themes/basic/genindex-single.html

@@ -30,7 +30,8 @@
 {% set title = _('Index') %}
 {% block body %}
 
-<h1 id="index">{% trans key=key %}Index &ndash; {{ key }}{% endtrans %}</h1>
+{# We use ``&#x2013;`` instead of ``&ndash;`` for XHTML compatibility #}
+<h1 id="index">{% trans key=key %}Index &#x2013; {{ key }}{% endtrans %}</h1>
 
 <table style="width: 100%" class="indextable"><tr>
   {%- for column in entries|slice(2) if column %}

sphinx/themes/basic/layout.html

@@ -22,7 +22,7 @@
 {%- endif %}
 
 {%- macro relbar() %}
-    <div class="related" role="navigation" aria-label="related navigation">
+    <div class="related" role="navigation" aria-label="Related">
       <h3>{{ _('Navigation') }}</h3>
       <ul>
         {%- for rellink in rellinks %}
@@ -45,12 +45,12 @@
 
 {%- macro sidebar() %}
       {%- if render_sidebar %}
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+      <div class="sphinxsidebar" role="navigation" aria-label="Main">
         <div class="sphinxsidebarwrapper">
           {%- block sidebarlogo %}
           {%- if logo_url %}
             <p class="logo"><a href="{{ pathto(root_doc)|e }}">
-              <img class="logo" src="{{ logo_url|e }}" alt="Logo"/>
+              <img class="logo" src="{{ logo_url|e }}" alt="{{ logo_alt|e }}"/>
             </a></p>
           {%- endif %}
           {%- endblock %}
@@ -70,9 +70,6 @@
             {%- block sidebarsourcelink %}
             {%- include "sourcelink.html" %}
             {%- endblock %}
-            {%- if customsidebar %}
-            {%- include customsidebar %}
-            {%- endif %}
             {%- block sidebarsearch %}
             {%- include "searchbox.html" %}
             {%- endblock %}

sphinx/themes/basic/static/searchtools.js

@@ -178,7 +178,7 @@ const Search = {
 
   htmlToText: (htmlString, anchor) => {
     const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html');
-    for (const removalQuery of [".headerlinks", "script", "style"]) {
+    for (const removalQuery of [".headerlink", "script", "style"]) {
       htmlElement.querySelectorAll(removalQuery).forEach((el) => { el.remove() });
     }
     if (anchor) {
@@ -328,13 +328,14 @@ const Search = {
     for (const [title, foundTitles] of Object.entries(allTitles)) {
       if (title.toLowerCase().trim().includes(queryLower) && (queryLower.length >= title.length/2)) {
         for (const [file, id] of foundTitles) {
-          let score = Math.round(100 * queryLower.length / title.length)
+          const score = Math.round(Scorer.title * queryLower.length / title.length);
+          const boost = titles[file] === title ? 1 : 0;  // add a boost for document titles
           normalResults.push([
             docNames[file],
             titles[file] !== title ? `${titles[file]} > ${title}` : title,
             id !== null ? "#" + id : "",
             null,
-            score,
+            score + boost,
             filenames[file],
           ]);
         }

sphinx/themes/haiku/layout.html

@@ -36,11 +36,11 @@
         {%- block haikuheader %}
         {%- if theme_full_logo != "false" %}
         <a href="{{ pathto(root_doc)|e }}">
-          <img class="logo" src="{{ logo_url|e }}" alt="Logo"/>
+          <img class="logo" src="{{ logo_url|e }}" alt="{{ logo_alt|e }}"/>
         </a>
         {%- else %}
         {%- if logo -%}
-          <img class="rightlogo" src="{{ logo_url|e }}" alt="Logo"/>
+          <img class="rightlogo" src="{{ logo_url|e }}" alt="{{ logo_alt|e }}"/>
         {%- endif -%}
         <h1 class="heading"><a href="{{ pathto(root_doc)|e }}">
           <span>{{ shorttitle|e }}</span></a></h1>
@@ -48,7 +48,7 @@
         {%- endif %}
         {%- endblock %}
       </div>
-      <div class="topnav" role="navigation" aria-label="top navigation">
+      <div class="topnav" role="navigation" aria-label="Top">
       {{ nav() }}
       </div>
       <div class="content" role="main">
@@ -60,7 +60,7 @@
         {%- endif %}#}
         {% block body %}{% endblock %}
       </div>
-      <div class="bottomnav" role="navigation" aria-label="bottom navigation">
+      <div class="bottomnav" role="navigation" aria-label="Bottom">
       {{ nav() }}
       </div>
 {% endblock %}

sphinx/themes/pyramid/layout.html

@@ -13,7 +13,7 @@
 <div class="header" role="banner">
   <div class="logo">
     <a href="{{ pathto(root_doc)|e }}">
-      <img class="logo" src="{{ logo_url|e }}" alt="Logo"/>
+      <img class="logo" src="{{ logo_url|e }}" alt="{{ logo_alt|e }}"/>
     </a>
   </div>
 </div>

sphinx/themes/scrolls/layout.html

@@ -26,7 +26,7 @@
         <h1 class="heading"><a href="{{ pathto(root_doc)|e }}"
           title="back to the documentation overview"><span>{{ title|striptags|e }}</span></a></h1>
       </div>
-      <div class="relnav" role="navigation" aria-label="related navigation">
+      <div class="relnav" role="navigation" aria-label="Related">
         {%- if prev %}
         <a href="{{ prev.link|e }}">&laquo; {{ prev.title }}</a> |
         {%- endif %}
@@ -37,7 +37,7 @@
       </div>
       <div id="contentwrapper">
         {%- if display_toc %}
-        <div id="toc" role="navigation" aria-label="table of contents navigation">
+        <div id="toc" role="navigation" aria-label="Table of contents">
           <h3>{{ _('Table of Contents') }}</h3>
           {{ toc }}
         </div>

sphinx/theming.py

@@ -32,6 +32,7 @@ else:
     from importlib_metadata import entry_points
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from typing import TypedDict
 
     from typing_extensions import Required
@@ -120,7 +121,17 @@ class Theme:
         elif section == 'options':
             value = self._options.get(name, default)
         else:
-            value = _NO_DEFAULT
+            # https://github.com/sphinx-doc/sphinx/issues/12305
+            # For backwards compatibility when attempting to read a value
+            # from an unsupported configuration section.
+            # xref: RemovedInSphinx80Warning
+            msg = __(
+                'Theme configuration sections other than [theme] and [options] '
+                'are not supported, returning the default value instead '
+                '(tried to get a value from %r)'
+            )
+            logger.info(msg, section)
+            value = default
         if value is _NO_DEFAULT:
             msg = __('setting %s.%s occurs in none of the searched theme configs') % (
                 section,
@@ -137,7 +148,7 @@ class Theme:
         options = self._options.copy()
         for option, value in overrides.items():
             if option not in options:
-                logger.warning(__('unsupported theme option %r given') % option)
+                logger.warning(__('unsupported theme option %r given'), option)
             else:
                 options[option] = value
 
@@ -156,6 +167,7 @@ class HTMLThemeFactory:
     def __init__(self, app: Sphinx) -> None:
         self._app = app
         self._themes = app.registry.html_themes
+        self._entry_point_themes: dict[str, Callable[[], None]] = {}
         self._load_builtin_themes()
         if getattr(app.config, 'html_theme_path', None):
             self._load_additional_themes(app.config.html_theme_path)
@@ -167,7 +179,7 @@ class HTMLThemeFactory:
         for name, theme in themes.items():
             self._themes[name] = theme
 
-    def _load_additional_themes(self, theme_paths: str) -> None:
+    def _load_additional_themes(self, theme_paths: list[str]) -> None:
         """Load additional themes placed at specified directories."""
         for theme_path in theme_paths:
             abs_theme_path = path.abspath(path.join(self._app.confdir, theme_path))
@@ -183,8 +195,16 @@ class HTMLThemeFactory:
         for entry_point in entry_points(group='sphinx.html_themes'):
             if entry_point.name in self._themes:
                 continue  # don't overwrite loaded themes
-            self._app.registry.load_extension(self._app, entry_point.module)
-            _config_post_init(self._app, self._app.config)
+
+            def _load_theme_closure(
+                # bind variables in the function definition
+                app: Sphinx = self._app,
+                theme_module: str = entry_point.module,
+            ) -> None:
+                app.setup_extension(theme_module)
+                _config_post_init(app, app.config)
+
+            self._entry_point_themes[entry_point.name] = _load_theme_closure
 
     @staticmethod
     def _find_themes(theme_path: str) -> dict[str, str]:
@@ -217,10 +237,18 @@ class HTMLThemeFactory:
 
     def create(self, name: str) -> Theme:
         """Create an instance of theme."""
+        if name in self._entry_point_themes:
+            # Load a deferred theme from an entry point
+            entry_point_loader = self._entry_point_themes[name]
+            entry_point_loader()
         if name not in self._themes:
             raise ThemeError(__('no theme named %r found (missing theme.toml?)') % name)
 
-        themes, theme_dirs, tmp_dirs = _load_theme_with_ancestors(self._themes, name)
+        themes, theme_dirs, tmp_dirs = _load_theme_with_ancestors(
+            name,
+            self._themes,
+            self._entry_point_themes,
+        )
         return Theme(name, configs=themes, paths=theme_dirs, tmp_dirs=tmp_dirs)
 
 
@@ -235,7 +263,10 @@ def _is_archived_theme(filename: str, /) -> bool:
 
 
 def _load_theme_with_ancestors(
-    theme_paths: dict[str, str], name: str, /
+    name: str,
+    theme_paths: dict[str, str],
+    entry_point_themes: dict[str, Callable[[], None]],
+    /,
 ) -> tuple[dict[str, _ConfigFile], list[str], list[str]]:
     themes: dict[str, _ConfigFile] = {}
     theme_dirs: list[str] = []
@@ -253,6 +284,10 @@ def _load_theme_with_ancestors(
         if inherit in themes:
             msg = __('The %r theme has circular inheritance') % name
             raise ThemeError(msg)
+        if inherit in entry_point_themes and inherit not in theme_paths:
+            # Load a deferred theme from an entry point
+            entry_point_loader = entry_point_themes[inherit]
+            entry_point_loader()
         if inherit not in theme_paths:
             msg = __(
                 'The %r theme inherits from %r, which is not a loaded theme. '

sphinx/transforms/__init__.py

@@ -22,8 +22,10 @@ from sphinx.util.nodes import apply_source_workaround, is_smartquotable
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
+    from typing import Literal
 
     from docutils.nodes import Node, Text
+    from typing_extensions import TypeAlias, TypeIs
 
     from sphinx.application import Sphinx
     from sphinx.config import Config
@@ -31,15 +33,22 @@ if TYPE_CHECKING:
     from sphinx.environment import BuildEnvironment
     from sphinx.util.typing import ExtensionMetadata
 
+    _DEFAULT_SUBSTITUTION_NAMES: TypeAlias = Literal[
+        'version',
+        'release',
+        'today',
+        'translation progress',
+    ]
+
 
 logger = logging.getLogger(__name__)
 
-default_substitutions = {
+_DEFAULT_SUBSTITUTIONS = frozenset({
     'version',
     'release',
     'today',
     'translation progress',
-}
+})
 
 
 class SphinxTransform(Transform):
@@ -105,20 +114,25 @@ class DefaultSubstitutions(SphinxTransform):
 
     def apply(self, **kwargs: Any) -> None:
         # only handle those not otherwise defined in the document
-        to_handle = default_substitutions - set(self.document.substitution_defs)
+        to_handle = _DEFAULT_SUBSTITUTIONS - set(self.document.substitution_defs)
         for ref in self.document.findall(nodes.substitution_reference):
-            refname = ref['refname']
-            if refname in to_handle:
-                if refname == 'translation progress':
-                    # special handling: calculate translation progress
-                    text = _calculate_translation_progress(self.document)
-                else:
-                    text = self.config[refname]
-                if refname == 'today' and not text:
-                    # special handling: can also specify a strftime format
-                    text = format_date(self.config.today_fmt or _('%b %d, %Y'),
-                                       language=self.config.language)
-                ref.replace_self(nodes.Text(text))
+            if (name := ref['refname']) in to_handle:
+                ref.replace_self(self._handle_default_substitution(name))
+
+    def _handle_default_substitution(self, name: _DEFAULT_SUBSTITUTION_NAMES) -> nodes.Text:
+        if name == 'translation progress':
+            # special handling: calculate translation progress
+            return nodes.Text(_calculate_translation_progress(self.document))
+        if name == 'today':
+            if text := self.config.today:
+                return nodes.Text(text)
+            # special handling: can also specify a strftime format
+            return nodes.Text(format_date(
+                self.config.today_fmt or _('%b %d, %Y'),
+                language=self.config.language,
+            ))
+        # config.version and config.release
+        return nodes.Text(getattr(self.config, name))
 
 
 def _calculate_translation_progress(document: nodes.document) -> str:
@@ -263,15 +277,15 @@ class ExtraTranslatableNodes(SphinxTransform):
     default_priority = 10
 
     def apply(self, **kwargs: Any) -> None:
-        targets = self.config.gettext_additional_targets
-        target_nodes = [v for k, v in TRANSLATABLE_NODES.items() if k in targets]
+        targets = frozenset(self.config.gettext_additional_targets)
+        target_nodes = tuple(v for k, v in TRANSLATABLE_NODES.items() if k in targets)
         if not target_nodes:
             return
 
-        def is_translatable_node(node: Node) -> bool:
-            return isinstance(node, tuple(target_nodes))
+        def is_translatable_node(node: Node) -> TypeIs[nodes.Element]:
+            return isinstance(node, target_nodes)
 
-        for node in self.document.findall(is_translatable_node):  # type: nodes.Element
+        for node in self.document.findall(is_translatable_node):
             node['translatable'] = True
 
 

sphinx/transforms/i18n.py

@@ -64,7 +64,7 @@ def publish_msgstr(app: Sphinx, source: str, source_path: str, source_line: int,
     try:
         # clear rst_prolog temporarily
         rst_prolog = config.rst_prolog
-        config.rst_prolog = None  # type: ignore[attr-defined]
+        config.rst_prolog = None
 
         from sphinx.io import SphinxI18nReader
         reader = SphinxI18nReader()
@@ -81,7 +81,7 @@ def publish_msgstr(app: Sphinx, source: str, source_path: str, source_line: int,
             return doc[0]
         return doc
     finally:
-        config.rst_prolog = rst_prolog  # type: ignore[attr-defined]
+        config.rst_prolog = rst_prolog
 
 
 def parse_noqa(source: str) -> tuple[str, bool]:
@@ -364,9 +364,9 @@ class Locale(SphinxTransform):
         for node, msg in extract_messages(self.document):
             msgstr = merged.get(msg, '')
 
-            # There is no point in having #noqa on literal blocks because
+            # There is no point in having noqa on literal blocks because
             # they cannot contain references.  Recognizing it would just
-            # completely prevent escaping the #noqa.  Outside of literal
+            # completely prevent escaping the noqa.  Outside of literal
             # blocks, one can always write \#noqa.
             if not isinstance(node, LITERAL_TYPE_NODES):
                 msgstr, _ = parse_noqa(msgstr)
@@ -406,12 +406,13 @@ class Locale(SphinxTransform):
             # glossary terms update refid
             if isinstance(node, nodes.term):
                 for _id in node['ids']:
-                    parts = split_term_classifiers(msgstr)
+                    term, first_classifier = split_term_classifiers(msgstr)
                     patch = publish_msgstr(
-                        self.app, parts[0] or '', source, node.line, self.config, settings,  # type: ignore[arg-type]
+                        self.app, term or '', source, node.line, self.config, settings,  # type: ignore[arg-type]
                     )
                     updater.patch = make_glossary_term(
-                        self.env, patch, parts[1] or '', source, node.line, _id, self.document,  # type: ignore[arg-type]
+                        self.env, patch, first_classifier,
+                        source, node.line, _id, self.document,  # type: ignore[arg-type]
                     )
                     processed = True
 

sphinx/transforms/post_transforms/__init__.py

@@ -98,7 +98,7 @@ class ReferencesResolver(SphinxPostTransform):
                                                         node, contnode,
                                                         allowed_exceptions=(NoUri,))
                     # still not found? warn if node wishes to be warned about or
-                    # we are in nit-picky mode
+                    # we are in nitpicky mode
                     if newnode is None:
                         self.warn_missing_reference(refdoc, typ, target, node, domain)
             except NoUri:

sphinx/transforms/post_transforms/images.py

@@ -80,8 +80,8 @@ class ImageDownloader(BaseImageConverter):
                 _tls_info=(config.tls_verify, config.tls_cacerts),
             )
             if r.status_code >= 400:
-                logger.warning(__('Could not fetch remote image: %s [%d]') %
-                               (node['uri'], r.status_code))
+                logger.warning(__('Could not fetch remote image: %s [%d]'),
+                               node['uri'], r.status_code)
             else:
                 self.app.env.original_image_uri[path] = node['uri']
 
@@ -108,17 +108,15 @@ class ImageDownloader(BaseImageConverter):
                 node['uri'] = path
                 self.app.env.images.add_file(self.env.docname, path)
         except Exception as exc:
-            logger.warning(__('Could not fetch remote image: %s [%s]') % (node['uri'], exc))
+            logger.warning(__('Could not fetch remote image: %s [%s]'), node['uri'], exc)
 
 
 class DataURIExtractor(BaseImageConverter):
     default_priority = 150
 
     def match(self, node: nodes.image) -> bool:
-        if not self.app.builder.supported_remote_images:
-            return False
         if self.app.builder.supported_data_uri_images is True:
-            return False
+            return False  # do not transform the image; data URIs are valid in the build output
         return node['uri'].startswith('data:')
 
     def handle(self, node: nodes.image) -> None:
@@ -192,9 +190,6 @@ class ImageConverter(BaseImageConverter):
     #:     ]
     conversion_rules: list[tuple[str, str]] = []
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
     def match(self, node: nodes.image) -> bool:
         if not self.app.builder.supported_image_types:
             return False
@@ -232,10 +227,12 @@ class ImageConverter(BaseImageConverter):
         raise NotImplementedError
 
     def guess_mimetypes(self, node: nodes.image) -> list[str]:
+        # The special key ? is set for nonlocal URIs.
         if '?' in node['candidates']:
             return []
         elif '*' in node['candidates']:
-            guessed = guess_mimetype(node['uri'])
+            path = os.path.join(self.app.srcdir, node['uri'])
+            guessed = guess_mimetype(path)
             return [guessed] if guessed is not None else []
         else:
             return node['candidates'].keys()

sphinx/util/_pathlib.py

@@ -28,7 +28,7 @@ if sys.platform == 'win32':
             # replace exists in both Path and str;
             # in Path it makes filesystem changes, so we use the safer str version
             warnings.warn(_MSG, RemovedInSphinx80Warning, stacklevel=2)
-            return self.__str__().replace(old, new, count)
+            return self.__str__().replace(old, new, count)  # NoQA:  PLC2801
 
         def __getattr__(self, item: str) -> Any:
             if item in _STR_METHODS:
@@ -77,7 +77,7 @@ else:
             # replace exists in both Path and str;
             # in Path it makes filesystem changes, so we use the safer str version
             warnings.warn(_MSG, RemovedInSphinx80Warning, stacklevel=2)
-            return self.__str__().replace(old, new, count)
+            return self.__str__().replace(old, new, count)  # NoQA:  PLC2801
 
         def __getattr__(self, item: str) -> Any:
             if item in _STR_METHODS:

sphinx/util/cfamily.py

@@ -90,17 +90,11 @@ class NoOldIdError(Exception):
 class ASTBaseBase:
     def __eq__(self, other: object) -> bool:
         if type(self) is not type(other):
-            return False
+            return NotImplemented
         try:
-            for key, value in self.__dict__.items():
-                if value != getattr(other, key):
-                    return False
+            return self.__dict__ == other.__dict__
         except AttributeError:
             return False
-        return True
-
-    # Defining __hash__ = None is not strictly needed when __eq__ is defined.
-    __hash__ = None  # type: ignore[assignment]
 
     def clone(self) -> Any:
         return deepcopy(self)
@@ -115,7 +109,7 @@ class ASTBaseBase:
         return self._stringify(lambda ast: ast.get_display_string())
 
     def __repr__(self) -> str:
-        return '<%s>' % self.__class__.__name__
+        return f'<{self.__class__.__name__}: {self._stringify(repr)}>'
 
 
 ################################################################################
@@ -131,8 +125,16 @@ class ASTCPPAttribute(ASTAttribute):
     def __init__(self, arg: str) -> None:
         self.arg = arg
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ASTCPPAttribute):
+            return NotImplemented
+        return self.arg == other.arg
+
+    def __hash__(self) -> int:
+        return hash(self.arg)
+
     def _stringify(self, transform: StringifyTransform) -> str:
-        return "[[" + self.arg + "]]"
+        return f"[[{self.arg}]]"
 
     def describe_signature(self, signode: TextElement) -> None:
         signode.append(addnodes.desc_sig_punctuation('[[', '[['))
@@ -146,35 +148,37 @@ class ASTGnuAttribute(ASTBaseBase):
         self.args = args
 
     def __eq__(self, other: object) -> bool:
-        if type(other) is not ASTGnuAttribute:
+        if not isinstance(other, ASTGnuAttribute):
             return NotImplemented
         return self.name == other.name and self.args == other.args
 
+    def __hash__(self) -> int:
+        return hash((self.name, self.args))
+
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = [self.name]
         if self.args:
-            res.append(transform(self.args))
-        return ''.join(res)
+            return self.name + transform(self.args)
+        return self.name
 
 
 class ASTGnuAttributeList(ASTAttribute):
     def __init__(self, attrs: list[ASTGnuAttribute]) -> None:
         self.attrs = attrs
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ASTGnuAttributeList):
+            return NotImplemented
+        return self.attrs == other.attrs
+
+    def __hash__(self) -> int:
+        return hash(self.attrs)
+
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = ['__attribute__((']
-        first = True
-        for attr in self.attrs:
-            if not first:
-                res.append(', ')
-            first = False
-            res.append(transform(attr))
-        res.append('))')
-        return ''.join(res)
+        attrs = ', '.join(map(transform, self.attrs))
+        return f'__attribute__(({attrs}))'
 
     def describe_signature(self, signode: TextElement) -> None:
-        txt = str(self)
-        signode.append(nodes.Text(txt))
+        signode.append(nodes.Text(str(self)))
 
 
 class ASTIdAttribute(ASTAttribute):
@@ -183,6 +187,14 @@ class ASTIdAttribute(ASTAttribute):
     def __init__(self, id: str) -> None:
         self.id = id
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ASTIdAttribute):
+            return NotImplemented
+        return self.id == other.id
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
     def _stringify(self, transform: StringifyTransform) -> str:
         return self.id
 
@@ -197,12 +209,19 @@ class ASTParenAttribute(ASTAttribute):
         self.id = id
         self.arg = arg
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ASTParenAttribute):
+            return NotImplemented
+        return self.id == other.id and self.arg == other.arg
+
+    def __hash__(self) -> int:
+        return hash((self.id, self.arg))
+
     def _stringify(self, transform: StringifyTransform) -> str:
-        return self.id + '(' + self.arg + ')'
+        return f'{self.id}({self.arg})'
 
     def describe_signature(self, signode: TextElement) -> None:
-        txt = str(self)
-        signode.append(nodes.Text(txt))
+        signode.append(nodes.Text(str(self)))
 
 
 class ASTAttributeList(ASTBaseBase):
@@ -210,10 +229,13 @@ class ASTAttributeList(ASTBaseBase):
         self.attrs = attrs
 
     def __eq__(self, other: object) -> bool:
-        if type(other) is not ASTAttributeList:
+        if not isinstance(other, ASTAttributeList):
             return NotImplemented
         return self.attrs == other.attrs
 
+    def __hash__(self) -> int:
+        return hash(self.attrs)
+
     def __len__(self) -> int:
         return len(self.attrs)
 
@@ -221,7 +243,7 @@ class ASTAttributeList(ASTBaseBase):
         return ASTAttributeList(self.attrs + other.attrs)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        return ' '.join(transform(attr) for attr in self.attrs)
+        return ' '.join(map(transform, self.attrs))
 
     def describe_signature(self, signode: TextElement) -> None:
         if len(self.attrs) == 0: