diff --git a/sphinx/writers/html.py b/sphinx/writers/html.py index 381457926..d283398f0 100644 --- a/sphinx/writers/html.py +++ b/sphinx/writers/html.py @@ -13,9 +13,11 @@ import os import posixpath import sys import warnings -from typing import Iterable, cast +from typing import cast +from typing import Iterable from docutils import nodes +from docutils.nodes import Element, Node, Text from docutils.writers.html4css1 import Writer, HTMLTranslator as BaseTranslator from sphinx import addnodes @@ -28,8 +30,7 @@ from sphinx.util.images import get_image_size if False: # For type annotation - from typing import Any # NOQA - from sphinx.builders.html import StandaloneHTMLBuilder # NOQA + from sphinx.builders.html import StandaloneHTMLBuilder logger = logging.getLogger(__name__) @@ -46,13 +47,11 @@ class HTMLWriter(Writer): if '--embed-stylesheet' in _setting[1]: _setting[2]['default'] = 0 - def __init__(self, builder): - # type: (StandaloneHTMLBuilder) -> None + def __init__(self, builder: "StandaloneHTMLBuilder") -> None: super().__init__() self.builder = builder - def translate(self): - # type: () -> None + def translate(self) -> None: # sadly, this is mostly copied from parent class visitor = self.builder.create_translator(self.document, self.builder) self.visitor = cast(HTMLTranslator, visitor) @@ -74,8 +73,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): builder = None # type: StandaloneHTMLBuilder - def __init__(self, *args): - # type: (Any) -> None + def __init__(self, *args) -> None: if isinstance(args[0], nodes.document) and isinstance(args[1], Builder): document, builder = args else: @@ -101,26 +99,21 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self._fieldlist_row_index = 0 self.required_params_left = 0 - def visit_start_of_file(self, node): - # type: (nodes.Element) -> None + def visit_start_of_file(self, node: Element) -> None: # only occurs in the single-file builder self.docnames.append(node['docname']) self.body.append('' % node['docname']) - def depart_start_of_file(self, node): - # type: (nodes.Element) -> None + def depart_start_of_file(self, node: Element) -> None: self.docnames.pop() - def visit_desc(self, node): - # type: (nodes.Element) -> None + def visit_desc(self, node: Element) -> None: self.body.append(self.starttag(node, 'dl', CLASS=node['objtype'])) - def depart_desc(self, node): - # type: (nodes.Element) -> None + def depart_desc(self, node: Element) -> None: self.body.append('\n\n') - def visit_desc_signature(self, node): - # type: (nodes.Element) -> None + def visit_desc_signature(self, node: Element) -> None: # the id is set automatically self.body.append(self.starttag(node, 'dt')) # anchor for per-desc interactive data @@ -128,57 +121,45 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): and node['ids'] and node['first']: self.body.append('' % node['ids'][0]) - def depart_desc_signature(self, node): - # type: (nodes.Element) -> None + def depart_desc_signature(self, node: Element) -> None: if not node.get('is_multiline'): self.add_permalink_ref(node, _('Permalink to this definition')) self.body.append('\n') - def visit_desc_signature_line(self, node): - # type: (nodes.Element) -> None + def visit_desc_signature_line(self, node: Element) -> None: pass - def depart_desc_signature_line(self, node): - # type: (nodes.Element) -> None + def depart_desc_signature_line(self, node: Element) -> None: if node.get('add_permalink'): # the permalink info is on the parent desc_signature node self.add_permalink_ref(node.parent, _('Permalink to this definition')) self.body.append('
') - def visit_desc_addname(self, node): - # type: (nodes.Element) -> None + def visit_desc_addname(self, node: Element) -> None: self.body.append(self.starttag(node, 'code', '', CLASS='descclassname')) - def depart_desc_addname(self, node): - # type: (nodes.Element) -> None + def depart_desc_addname(self, node: Element) -> None: self.body.append('') - def visit_desc_type(self, node): - # type: (nodes.Element) -> None + def visit_desc_type(self, node: Element) -> None: pass - def depart_desc_type(self, node): - # type: (nodes.Element) -> None + def depart_desc_type(self, node: Element) -> None: pass - def visit_desc_returns(self, node): - # type: (nodes.Element) -> None + def visit_desc_returns(self, node: Element) -> None: self.body.append(' → ') - def depart_desc_returns(self, node): - # type: (nodes.Element) -> None + def depart_desc_returns(self, node: Element) -> None: pass - def visit_desc_name(self, node): - # type: (nodes.Element) -> None + def visit_desc_name(self, node: Element) -> None: self.body.append(self.starttag(node, 'code', '', CLASS='descname')) - def depart_desc_name(self, node): - # type: (nodes.Element) -> None + def depart_desc_name(self, node: Element) -> None: self.body.append('') - def visit_desc_parameterlist(self, node): - # type: (nodes.Element) -> None + def visit_desc_parameterlist(self, node: Element) -> None: self.body.append('(') self.first_param = 1 self.optional_param_level = 0 @@ -187,8 +168,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): for c in node.children]) self.param_separator = node.child_text_separator - def depart_desc_parameterlist(self, node): - # type: (nodes.Element) -> None + def depart_desc_parameterlist(self, node: Element) -> None: self.body.append(')') # If required parameters are still to come, then put the comma after @@ -197,8 +177,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): # # foo([a, ]b, c[, d]) # - def visit_desc_parameter(self, node): - # type: (nodes.Element) -> None + def visit_desc_parameter(self, node: Element) -> None: if self.first_param: self.first_param = 0 elif not self.required_params_left: @@ -208,50 +187,40 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): if not node.hasattr('noemph'): self.body.append('') - def depart_desc_parameter(self, node): - # type: (nodes.Element) -> None + def depart_desc_parameter(self, node: Element) -> None: if not node.hasattr('noemph'): self.body.append('') if self.required_params_left: self.body.append(self.param_separator) - def visit_desc_optional(self, node): - # type: (nodes.Element) -> None + def visit_desc_optional(self, node: Element) -> None: self.optional_param_level += 1 self.body.append('[') - def depart_desc_optional(self, node): - # type: (nodes.Element) -> None + def depart_desc_optional(self, node: Element) -> None: self.optional_param_level -= 1 self.body.append(']') - def visit_desc_annotation(self, node): - # type: (nodes.Element) -> None + def visit_desc_annotation(self, node: Element) -> None: self.body.append(self.starttag(node, 'em', '', CLASS='property')) - def depart_desc_annotation(self, node): - # type: (nodes.Element) -> None + def depart_desc_annotation(self, node: Element) -> None: self.body.append('') - def visit_desc_content(self, node): - # type: (nodes.Element) -> None + def visit_desc_content(self, node: Element) -> None: self.body.append(self.starttag(node, 'dd', '')) - def depart_desc_content(self, node): - # type: (nodes.Element) -> None + def depart_desc_content(self, node: Element) -> None: self.body.append('') - def visit_versionmodified(self, node): - # type: (nodes.Element) -> None + def visit_versionmodified(self, node: Element) -> None: self.body.append(self.starttag(node, 'div', CLASS=node['type'])) - def depart_versionmodified(self, node): - # type: (nodes.Element) -> None + def depart_versionmodified(self, node: Element) -> None: self.body.append('\n') # overwritten - def visit_reference(self, node): - # type: (nodes.Element) -> None + def visit_reference(self, node: Element) -> None: atts = {'class': 'reference'} if node.get('internal') or 'refuri' not in node: atts['class'] += ' internal' @@ -279,38 +248,31 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.body.append(('%s' + self.secnumber_suffix) % '.'.join(map(str, node['secnumber']))) - def visit_number_reference(self, node): - # type: (nodes.Element) -> None + def visit_number_reference(self, node: Element) -> None: self.visit_reference(node) - def depart_number_reference(self, node): - # type: (nodes.Element) -> None + def depart_number_reference(self, node: Element) -> None: self.depart_reference(node) # overwritten -- we don't want source comments to show up in the HTML - def visit_comment(self, node): # type: ignore - # type: (nodes.Element) -> None + def visit_comment(self, node: Element) -> None: # type: ignore raise nodes.SkipNode # overwritten - def visit_admonition(self, node, name=''): - # type: (nodes.Element, str) -> None + def visit_admonition(self, node: Element, name: str = '') -> None: self.body.append(self.starttag( node, 'div', CLASS=('admonition ' + name))) if name: node.insert(0, nodes.title(name, admonitionlabels[name])) self.set_first_last(node) - def visit_seealso(self, node): - # type: (nodes.Element) -> None + def visit_seealso(self, node: Element) -> None: self.visit_admonition(node, 'seealso') - def depart_seealso(self, node): - # type: (nodes.Element) -> None + def depart_seealso(self, node: Element) -> None: self.depart_admonition(node) - def add_secnumber(self, node): - # type: (nodes.Element) -> None + def add_secnumber(self, node: Element) -> None: if node.get('secnumber'): self.body.append('.'.join(map(str, node['secnumber'])) + self.secnumber_suffix) @@ -329,10 +291,8 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.body.append('.'.join(map(str, numbers)) + self.secnumber_suffix) - def add_fignumber(self, node): - # type: (nodes.Element) -> None - def append_fignumber(figtype, figure_id): - # type: (str, str) -> None + def add_fignumber(self, node: Element) -> None: + def append_fignumber(figtype: str, figure_id: str) -> None: if self.builder.name == 'singlehtml': key = "%s/%s" % (self.docnames[-1], figtype) else: @@ -357,14 +317,12 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): else: append_fignumber(figtype, node['ids'][0]) - def add_permalink_ref(self, node, title): - # type: (nodes.Element, str) -> None + def add_permalink_ref(self, node: Element, title: str) -> None: if node['ids'] and self.permalink_text and self.builder.add_permalinks: format = '%s' self.body.append(format % (node['ids'][0], title, self.permalink_text)) - def generate_targets_for_listing(self, node): - # type: (nodes.Element) -> None + def generate_targets_for_listing(self, node: Element) -> None: """Generate hyperlink targets for listings. Original visit_bullet_list(), visit_definition_list() and visit_enumerated_list() @@ -379,8 +337,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): node['ids'].remove(id) # overwritten - def visit_bullet_list(self, node): - # type: (nodes.Element) -> None + def visit_bullet_list(self, node: Element) -> None: if len(node) == 1 and isinstance(node[0], addnodes.toctree): # avoid emitting empty raise nodes.SkipNode @@ -388,46 +345,39 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): super().visit_bullet_list(node) # overwritten - def visit_enumerated_list(self, node): - # type: (nodes.Element) -> None + def visit_enumerated_list(self, node: Element) -> None: self.generate_targets_for_listing(node) super().visit_enumerated_list(node) # overwritten - def visit_definition(self, node): - # type: (nodes.Element) -> None + def visit_definition(self, node: Element) -> None: # don't insert here. self.body.append(self.starttag(node, 'dd', '')) # overwritten - def depart_definition(self, node): - # type: (nodes.Element) -> None + def depart_definition(self, node: Element) -> None: self.body.append('\n') # overwritten - def visit_classifier(self, node): - # type: (nodes.Element) -> None + def visit_classifier(self, node: Element) -> None: self.body.append(self.starttag(node, 'span', '', CLASS='classifier')) # overwritten - def depart_classifier(self, node): - # type: (nodes.Element) -> None + def depart_classifier(self, node: Element) -> None: self.body.append('') - next_node = node.next_node(descend=False, siblings=True) # type: nodes.Node + next_node = node.next_node(descend=False, siblings=True) # type: Node if not isinstance(next_node, nodes.classifier): # close `
` tag at the tail of classifiers self.body.append('
') # overwritten - def visit_term(self, node): - # type: (nodes.Element) -> None + def visit_term(self, node: Element) -> None: self.body.append(self.starttag(node, 'dt', '')) # overwritten - def depart_term(self, node): - # type: (nodes.Element) -> None - next_node = node.next_node(descend=False, siblings=True) # type: nodes.Node + def depart_term(self, node: Element) -> None: + next_node = node.next_node(descend=False, siblings=True) # type: Node if isinstance(next_node, nodes.classifier): # Leave the end tag to `self.depart_classifier()`, in case # there's a classifier. @@ -436,16 +386,14 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.body.append('') # overwritten - def visit_title(self, node): - # type: (nodes.Element) -> None + def visit_title(self, node: Element) -> None: super().visit_title(node) self.add_secnumber(node) self.add_fignumber(node.parent) if isinstance(node.parent, nodes.table): self.body.append('') - def depart_title(self, node): - # type: (nodes.Element) -> None + def depart_title(self, node: Element) -> None: close_tag = self.context[-1] if (self.permalink_text and self.builder.add_permalinks and node.parent.hasattr('ids') and node.parent['ids']): @@ -467,8 +415,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): super().depart_title(node) # overwritten - def visit_literal_block(self, node): - # type: (nodes.Element) -> None + def visit_literal_block(self, node: Element) -> None: if node.rawsource != node.astext(): # most probably a parsed-literal block -- don't highlight return super().visit_literal_block(node) @@ -492,8 +439,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.body.append(starttag + highlighted + '\n') raise nodes.SkipNode - def visit_caption(self, node): - # type: (nodes.Element) -> None + def visit_caption(self, node: Element) -> None: if isinstance(node.parent, nodes.container) and node.parent.get('literal_block'): self.body.append('
') else: @@ -501,8 +447,7 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.add_fignumber(node.parent) self.body.append(self.starttag(node, 'span', '', CLASS='caption-text')) - def depart_caption(self, node): - # type: (nodes.Element) -> None + def depart_caption(self, node: Element) -> None: self.body.append('') # append permalink if available @@ -518,22 +463,18 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): else: super().depart_caption(node) - def visit_doctest_block(self, node): - # type: (nodes.Element) -> None + def visit_doctest_block(self, node: Element) -> None: self.visit_literal_block(node) # overwritten to add the
(for XHTML compliance) - def visit_block_quote(self, node): - # type: (nodes.Element) -> None + def visit_block_quote(self, node: Element) -> None: self.body.append(self.starttag(node, 'blockquote') + '
') - def depart_block_quote(self, node): - # type: (nodes.Element) -> None + def depart_block_quote(self, node: Element) -> None: self.body.append('
\n') # overwritten - def visit_literal(self, node): - # type: (nodes.Element) -> None + def visit_literal(self, node: Element) -> None: if 'kbd' in node['classes']: self.body.append(self.starttag(node, 'kbd', '', CLASS='docutils literal notranslate')) @@ -542,16 +483,14 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): CLASS='docutils literal notranslate')) self.protect_literal_text += 1 - def depart_literal(self, node): - # type: (nodes.Element) -> None + def depart_literal(self, node: Element) -> None: if 'kbd' in node['classes']: self.body.append('') else: self.protect_literal_text -= 1 self.body.append('') - def visit_productionlist(self, node): - # type: (nodes.Element) -> None + def visit_productionlist(self, node: Element) -> None: self.body.append(self.starttag(node, 'pre')) names = [] productionlist = cast(Iterable[addnodes.production], node) @@ -571,30 +510,24 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.body.append('\n') raise nodes.SkipNode - def depart_productionlist(self, node): - # type: (nodes.Element) -> None + def depart_productionlist(self, node: Element) -> None: pass - def visit_production(self, node): - # type: (nodes.Element) -> None + def visit_production(self, node: Element) -> None: pass - def depart_production(self, node): - # type: (nodes.Element) -> None + def depart_production(self, node: Element) -> None: pass - def visit_centered(self, node): - # type: (nodes.Element) -> None + def visit_centered(self, node: Element) -> None: self.body.append(self.starttag(node, 'p', CLASS="centered") + '') - def depart_centered(self, node): - # type: (nodes.Element) -> None + def depart_centered(self, node: Element) -> None: self.body.append('

') # overwritten - def should_be_compact_paragraph(self, node): - # type: (nodes.Node) -> bool + def should_be_compact_paragraph(self, node: Node) -> bool: """Determine if the

tags around paragraph can be omitted.""" if isinstance(node.parent, addnodes.desc_content): # Never compact desc_content items. @@ -604,16 +537,13 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): return False return super().should_be_compact_paragraph(node) - def visit_compact_paragraph(self, node): - # type: (nodes.Element) -> None + def visit_compact_paragraph(self, node: Element) -> None: pass - def depart_compact_paragraph(self, node): - # type: (nodes.Element) -> None + def depart_compact_paragraph(self, node: Element) -> None: pass - def visit_download_reference(self, node): - # type: (nodes.Element) -> None + def visit_download_reference(self, node: Element) -> None: atts = {'class': 'reference download', 'download': ''} @@ -632,13 +562,11 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): else: self.context.append('') - def depart_download_reference(self, node): - # type: (nodes.Element) -> None + def depart_download_reference(self, node: Element) -> None: self.body.append(self.context.pop()) # overwritten - def visit_image(self, node): - # type: (nodes.Element) -> None + def visit_image(self, node: Element) -> None: olduri = node['uri'] # rewrite the URI if the environment knows about it if olduri in self.builder.images: @@ -679,67 +607,53 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): super().visit_image(node) # overwritten - def depart_image(self, node): - # type: (nodes.Element) -> None + def depart_image(self, node: Element) -> None: if node['uri'].lower().endswith(('svg', 'svgz')): self.body.append(self.context.pop()) else: super().depart_image(node) - def visit_toctree(self, node): - # type: (nodes.Element) -> None + def visit_toctree(self, node: Element) -> None: # this only happens when formatting a toc from env.tocs -- in this # case we don't want to include the subtree raise nodes.SkipNode - def visit_index(self, node): - # type: (nodes.Element) -> None + def visit_index(self, node: Element) -> None: raise nodes.SkipNode - def visit_tabular_col_spec(self, node): - # type: (nodes.Element) -> None + def visit_tabular_col_spec(self, node: Element) -> None: raise nodes.SkipNode - def visit_glossary(self, node): - # type: (nodes.Element) -> None + def visit_glossary(self, node: Element) -> None: pass - def depart_glossary(self, node): - # type: (nodes.Element) -> None + def depart_glossary(self, node: Element) -> None: pass - def visit_acks(self, node): - # type: (nodes.Element) -> None + def visit_acks(self, node: Element) -> None: pass - def depart_acks(self, node): - # type: (nodes.Element) -> None + def depart_acks(self, node: Element) -> None: pass - def visit_hlist(self, node): - # type: (nodes.Element) -> None + def visit_hlist(self, node: Element) -> None: self.body.append('') - def depart_hlist(self, node): - # type: (nodes.Element) -> None + def depart_hlist(self, node: Element) -> None: self.body.append('
\n') - def visit_hlistcol(self, node): - # type: (nodes.Element) -> None + def visit_hlistcol(self, node: Element) -> None: self.body.append('') - def depart_hlistcol(self, node): - # type: (nodes.Element) -> None + def depart_hlistcol(self, node: Element) -> None: self.body.append('') - def visit_option_group(self, node): - # type: (nodes.Element) -> None + def visit_option_group(self, node: Element) -> None: super().visit_option_group(node) self.context[-2] = self.context[-2].replace(' ', ' ') # overwritten - def visit_Text(self, node): - # type: (nodes.Text) -> None + def visit_Text(self, node: Text) -> None: text = node.astext() encoded = self.encode(text) if self.protect_literal_text: @@ -760,127 +674,99 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): encoded = self.cloak_email(encoded) self.body.append(encoded) - def visit_note(self, node): - # type: (nodes.Element) -> None + def visit_note(self, node: Element) -> None: self.visit_admonition(node, 'note') - def depart_note(self, node): - # type: (nodes.Element) -> None + def depart_note(self, node: Element) -> None: self.depart_admonition(node) - def visit_warning(self, node): - # type: (nodes.Element) -> None + def visit_warning(self, node: Element) -> None: self.visit_admonition(node, 'warning') - def depart_warning(self, node): - # type: (nodes.Element) -> None + def depart_warning(self, node: Element) -> None: self.depart_admonition(node) - def visit_attention(self, node): - # type: (nodes.Element) -> None + def visit_attention(self, node: Element) -> None: self.visit_admonition(node, 'attention') - def depart_attention(self, node): - # type: (nodes.Element) -> None + def depart_attention(self, node: Element) -> None: self.depart_admonition(node) - def visit_caution(self, node): - # type: (nodes.Element) -> None + def visit_caution(self, node: Element) -> None: self.visit_admonition(node, 'caution') - def depart_caution(self, node): - # type: (nodes.Element) -> None + def depart_caution(self, node: Element) -> None: self.depart_admonition(node) - def visit_danger(self, node): - # type: (nodes.Element) -> None + def visit_danger(self, node: Element) -> None: self.visit_admonition(node, 'danger') - def depart_danger(self, node): - # type: (nodes.Element) -> None + def depart_danger(self, node: Element) -> None: self.depart_admonition(node) - def visit_error(self, node): - # type: (nodes.Element) -> None + def visit_error(self, node: Element) -> None: self.visit_admonition(node, 'error') - def depart_error(self, node): - # type: (nodes.Element) -> None + def depart_error(self, node: Element) -> None: self.depart_admonition(node) - def visit_hint(self, node): - # type: (nodes.Element) -> None + def visit_hint(self, node: Element) -> None: self.visit_admonition(node, 'hint') - def depart_hint(self, node): - # type: (nodes.Element) -> None + def depart_hint(self, node: Element) -> None: self.depart_admonition(node) - def visit_important(self, node): - # type: (nodes.Element) -> None + def visit_important(self, node: Element) -> None: self.visit_admonition(node, 'important') - def depart_important(self, node): - # type: (nodes.Element) -> None + def depart_important(self, node: Element) -> None: self.depart_admonition(node) - def visit_tip(self, node): - # type: (nodes.Element) -> None + def visit_tip(self, node: Element) -> None: self.visit_admonition(node, 'tip') - def depart_tip(self, node): - # type: (nodes.Element) -> None + def depart_tip(self, node: Element) -> None: self.depart_admonition(node) - def visit_literal_emphasis(self, node): - # type: (nodes.Element) -> None + def visit_literal_emphasis(self, node: Element) -> None: return self.visit_emphasis(node) - def depart_literal_emphasis(self, node): - # type: (nodes.Element) -> None + def depart_literal_emphasis(self, node: Element) -> None: return self.depart_emphasis(node) - def visit_literal_strong(self, node): - # type: (nodes.Element) -> None + def visit_literal_strong(self, node: Element) -> None: return self.visit_strong(node) - def depart_literal_strong(self, node): - # type: (nodes.Element) -> None + def depart_literal_strong(self, node: Element) -> None: return self.depart_strong(node) - def visit_abbreviation(self, node): - # type: (nodes.Element) -> None + def visit_abbreviation(self, node: Element) -> None: attrs = {} if node.hasattr('explanation'): attrs['title'] = node['explanation'] self.body.append(self.starttag(node, 'abbr', '', **attrs)) - def depart_abbreviation(self, node): - # type: (nodes.Element) -> None + def depart_abbreviation(self, node: Element) -> None: self.body.append('') - def visit_manpage(self, node): - # type: (nodes.Element) -> None + def visit_manpage(self, node: Element) -> None: self.visit_literal_emphasis(node) if self.manpages_url: node['refuri'] = self.manpages_url.format(**node.attributes) self.visit_reference(node) - def depart_manpage(self, node): - # type: (nodes.Element) -> None + def depart_manpage(self, node: Element) -> None: if self.manpages_url: self.depart_reference(node) self.depart_literal_emphasis(node) # overwritten to add even/odd classes - def visit_table(self, node): - # type: (nodes.Element) -> None + def visit_table(self, node: Element) -> None: self._table_row_index = 0 return super().visit_table(node) - def visit_row(self, node): - # type: (nodes.Element) -> None + def visit_row(self, node: Element) -> None: self._table_row_index += 1 if self._table_row_index % 2 == 0: node['classes'].append('row-even') @@ -889,19 +775,16 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): self.body.append(self.starttag(node, 'tr', '')) node.column = 0 # type: ignore - def visit_entry(self, node): - # type: (nodes.Element) -> None + def visit_entry(self, node: Element) -> None: super().visit_entry(node) if self.body[-1] == ' ': self.body[-1] = ' ' - def visit_field_list(self, node): - # type: (nodes.Element) -> None + def visit_field_list(self, node: Element) -> None: self._fieldlist_row_index = 0 return super().visit_field_list(node) - def visit_field(self, node): - # type: (nodes.Element) -> None + def visit_field(self, node: Element) -> None: self._fieldlist_row_index += 1 if self._fieldlist_row_index % 2 == 0: node['classes'].append('field-even') @@ -909,69 +792,59 @@ class HTMLTranslator(SphinxTranslator, BaseTranslator): node['classes'].append('field-odd') self.body.append(self.starttag(node, 'tr', '', CLASS='field')) - def visit_field_name(self, node): - # type: (nodes.Element) -> None + def visit_field_name(self, node: Element) -> None: context_count = len(self.context) super().visit_field_name(node) if context_count != len(self.context): self.context[-1] = self.context[-1].replace(' ', ' ') - def visit_math(self, node, math_env=''): - # type: (nodes.Element, str) -> None + def visit_math(self, node: Element, math_env: str = '') -> None: name = self.builder.math_renderer_name visit, _ = self.builder.app.registry.html_inline_math_renderers[name] visit(self, node) - def depart_math(self, node, math_env=''): - # type: (nodes.Element, str) -> None + def depart_math(self, node: Element, math_env: str = '') -> None: name = self.builder.math_renderer_name _, depart = self.builder.app.registry.html_inline_math_renderers[name] if depart: depart(self, node) - def visit_math_block(self, node, math_env=''): - # type: (nodes.Element, str) -> None + def visit_math_block(self, node: Element, math_env: str = '') -> None: name = self.builder.math_renderer_name visit, _ = self.builder.app.registry.html_block_math_renderers[name] visit(self, node) - def depart_math_block(self, node, math_env=''): - # type: (nodes.Element, str) -> None + def depart_math_block(self, node: Element, math_env: str = '') -> None: name = self.builder.math_renderer_name _, depart = self.builder.app.registry.html_block_math_renderers[name] if depart: depart(self, node) - def unknown_visit(self, node): - # type: (nodes.Node) -> None + def unknown_visit(self, node: Node) -> None: raise NotImplementedError('Unknown node: ' + node.__class__.__name__) # --------- METHODS FOR COMPATIBILITY -------------------------------------- @property - def highlightlang(self): - # type: () -> str + def highlightlang(self) -> str: warnings.warn('HTMLTranslator.highlightlang is deprecated.', RemovedInSphinx30Warning, stacklevel=2) return self.builder.config.highlight_language @property - def highlightlang_base(self): - # type: () -> str + def highlightlang_base(self) -> str: warnings.warn('HTMLTranslator.highlightlang_base is deprecated.', RemovedInSphinx30Warning) return self.builder.config.highlight_language @property - def highlightopts(self): - # type: () -> str + def highlightopts(self) -> str: warnings.warn('HTMLTranslator.highlightopts is deprecated.', RemovedInSphinx30Warning, stacklevel=2) return self.builder.config.highlight_options @property - def highlightlinenothreshold(self): - # type: () -> int + def highlightlinenothreshold(self) -> int: warnings.warn('HTMLTranslator.highlightlinenothreshold is deprecated.', RemovedInSphinx30Warning, stacklevel=2) return sys.maxsize