Format tokens as HTML 4 “<span>“ tags within a “<pre>“ tag, wrapped in a “<div>“ tag. The “<div>“'s CSS class can be set by the `cssclass` option.

If the `linenos` option is set to “"table"“, the “<pre>“ is additionally wrapped inside a “<table>“ which has one row and two cells: one containing the line numbers and one containing the code. Example:

.. sourcecode:: html

<div class="highlight" >
  <td class="linenos" title="click to toggle"
    onclick="with (
             { display = (display == '') ? 'none' : '' }">
  <td class="code">
    <pre><span class="Ke">def </span><span class="NaFu">foo</span>(bar):
      <span class="Ke">pass</span>

(whitespace added to improve clarity).

Wrapping can be disabled using the `nowrap` option.

A list of lines can be specified using the `hl_lines` option to make these lines highlighted (as of Pygments 0.11).

With the `full` option, a complete HTML 4 document is output, including the style definitions inside a “<style>“ tag, or in a separate file if the `cssfile` option is given.

The `get_style_defs(arg=”)` method of a `HtmlFormatter` returns a string containing CSS rules for the CSS classes used by the formatter. The argument `arg` can be used to specify additional CSS selectors that are prepended to the classes. A call `fmter.get_style_defs('td .code')` would result in the following CSS classes:

.. sourcecode:: css

td .code .kw { font-weight: bold; color: #00FF00 }
td .code .cm { color: #999999 }

If you have Pygments 0.6 or higher, you can also pass a list or tuple to the `get_style_defs()` method to request multiple prefixes for the tokens:

.. sourcecode:: python

formatter.get_style_defs(['div.syntax pre', 'pre.syntax'])

The output would then look like this:

.. sourcecode:: css

div.syntax pre .kw,
pre.syntax .kw { font-weight: bold; color: #00FF00 }
div.syntax pre .cm,
pre.syntax .cm { color: #999999 }

Additional options accepted:


If set to ``True``, don't wrap the tokens at all, not even inside a ``<pre>``
tag. This disables most other options (default: ``False``).


Tells the formatter to output a "full" document, i.e. a complete
self-contained document (default: ``False``).


If `full` is true, the title that should be used to caption the
document (default: ``''``).


The style to use, can be a string or a Style subclass (default:
``'default'``). This option has no effect if the `cssfile`
and `noclobber_cssfile` option are given and the file specified in
`cssfile` exists.


If set to true, token ``<span>`` tags will not use CSS classes, but
inline styles. This is not recommended for larger pieces of code since
it increases output size by quite a bit (default: ``False``).


Since the token types use relatively short class names, they may clash
with some of your own class names. In this case you can use the
`classprefix` option to give a string to prepend to all Pygments-generated
CSS class names for token types.
Note that this option also affects the output of `get_style_defs()`.


CSS class for the wrapping ``<div>`` tag (default: ``'highlight'``).
If you set this option, the default selector for `get_style_defs()`
will be this class.

*New in Pygments 0.9:* If you select the ``'table'`` line numbers, the
wrapping table will have a CSS class of this string plus ``'table'``,
the default is accordingly ``'highlighttable'``.


Inline CSS styles for the wrapping ``<div>`` tag (default: ``''``).


Inline CSS styles for the ``<pre>`` tag (default: ``''``).  *New in
Pygments 0.11.*


If the `full` option is true and this option is given, it must be the
name of an external file. If the filename does not include an absolute
path, the file's path will be assumed to be relative to the main output
file's path, if the latter can be found. The stylesheet is then written
to this file instead of the HTML file. *New in Pygments 0.6.*


If `cssfile` is given and the specified file exists, the css file will
not be overwritten. This allows the use of the `full` option in
combination with a user specified css file. Default is ``False``.
*New in Pygments 1.1.*


If set to ``'table'``, output line numbers as a table with two cells,
one containing the line numbers, the other the whole code.  This is
copy-and-paste-friendly, but may cause alignment problems with some
browsers or fonts.  If set to ``'inline'``, the line numbers will be
integrated in the ``<pre>`` tag that contains the code (that setting
is *new in Pygments 0.8*).

For compatibility with Pygments 0.7 and earlier, every true value
except ``'inline'`` means the same as ``'table'`` (in particular, that
means also ``True``).

The default value is ``False``, which means no line numbers at all.

**Note:** with the default ("table") line number mechanism, the line
numbers and code can have different line heights in Internet Explorer
unless you give the enclosing ``<pre>`` tags an explicit ``line-height``
CSS property (you get the default line spacing with ``line-height:


Specify a list of lines to be highlighted.  *New in Pygments 0.11.*


The line number for the first line (default: ``1``).


If set to a number n > 1, only every nth line number is printed.


If set to a number n > 0, every nth line number is given the CSS
class ``"special"`` (default: ``0``).


If set to ``True``, the formatter won't output the background color
for the wrapping element (this automatically defaults to ``False``
when there is no wrapping element [eg: no argument for the
`get_syntax_defs` method given]) (default: ``False``). *New in
Pygments 0.6.*


This string is output between lines of code. It defaults to ``"\n"``,
which is enough to break a line inside ``<pre>`` tags, but you can
e.g. set it to ``"<br>"`` to get HTML line breaks. *New in Pygments


If set to a nonempty string, e.g. ``foo``, the formatter will wrap each
output line in an anchor tag with a ``name`` of ``foo-linenumber``.
This allows easy linking to certain lines. *New in Pygments 0.9.*


If set to `True`, will wrap line numbers in <a> tags. Used in
combination with `linenos` and `lineanchors`.

**Subclassing the HTML formatter**

*New in Pygments 0.7.*

The HTML formatter is now built in a way that allows easy subclassing, thus customizing the output HTML code. The `format()` method calls `self._format_lines()` which returns a generator that yields tuples of “(1, line)“, where the “1“ indicates that the “line“ is a line of the formatted source code.

If the `nowrap` option is set, the generator is the iterated over and the resulting HTML is output.

Otherwise, `format()` calls `self.wrap()`, which wraps the generator with other generators. These may add some HTML code to the one generated by `_format_lines()`, either by modifying the lines generated by the latter, then yielding them again with “(1, line)“, and/or by yielding other HTML code before or after the lines, with “(0, html)“. The distinction between source lines and other code makes it possible to wrap the generator multiple times.

The default `wrap()` implementation adds a “<div>“ and a “<pre>“ tag.

A custom `HtmlFormatter` subclass could look like this:

.. sourcecode:: python

class CodeHtmlFormatter(HtmlFormatter):

    def wrap(self, source, outfile):
        return self._wrap_code(source)

    def _wrap_code(self, source):
        yield 0, '<code>'
        for i, t in source:
            if i == 1:
                # it's a line of formatted code
                t += '<br>'
            yield i, t
        yield 0, '</code>'

This results in wrapping the formatted lines with a “<code>“ tag, where the source lines are broken using “<br>“ tags.

After calling `wrap()`, the `format()` method also adds the "line numbers" and/or "full document" wrappers if the respective options are set. Then, all HTML yielded by the wrapped generator is output.

name is referenced in 0 repositories


    name = 'HTML'