‹› markdown.inlinepatterns ¶

In version 3.0, a new, more flexible inline processor was added, markdown.inlinepatterns.InlineProcessor. The original inline patterns, which inherit from markdown.inlinepatterns.Pattern or one of its children are still supported, though users are encouraged to migrate.

The new InlineProcessor provides two major enhancements to Patterns:

1. Inline Processors no longer need to match the entire block, so regular expressions no longer need to start with r'^(.*?)' and end with r'(.*?)%'. This runs faster. The returned Match object will only contain what is explicitly matched in the pattern, and extension pattern groups now start with m.group(1).

2. The handleMatch method now takes an additional input called data, which is the entire block under analysis, not just what is matched with the specified pattern. The method now returns the element and the indexes relative to data that the return element is replacing (usually m.start(0) and m.end(0)). If the boundaries are returned as None, it is assumed that the match did not take place, and nothing will be altered in data.

   This allows handling of more complex constructs than regular expressions can handle, e.g., matching nested brackets, and explicit control of the span “consumed” by the processor.

Classes:

• EmStrongItem –

  Emphasis/strong pattern item.

• Pattern –

  Base class that inline patterns subclass.

• InlineProcessor –

  Base class that inline processors subclass.

• SimpleTextPattern –

  Return a simple text of group(2) of a Pattern.

• SimpleTextInlineProcessor –

  Return a simple text of group(1) of a Pattern.

• EscapeInlineProcessor –

  Return an escaped character.

• SimpleTagPattern –

  Return element of type tag with a text attribute of group(3)

• SimpleTagInlineProcessor –

  Return element of type tag with a text attribute of group(2)

• SubstituteTagPattern –

  Return an element of type tag with no children.

• SubstituteTagInlineProcessor –

  Return an element of type tag with no children.

• BacktickInlineProcessor –

  Return a <code> element containing the escaped matching text.

• DoubleTagPattern –

  Return a ElementTree element nested in tag2 nested in tag1.

• DoubleTagInlineProcessor –

  Return a ElementTree element nested in tag2 nested in tag1.

• HtmlInlineProcessor –

  Store raw inline html and return a placeholder.

• AsteriskProcessor –

  Emphasis processor for handling strong and em matches inside asterisks.

• UnderscoreProcessor –

  Emphasis processor for handling strong and em matches inside underscores.

• LinkInlineProcessor –

  Return a link element from the given match.

• ImageInlineProcessor –

  Return a img element from the given match.

• ReferenceInlineProcessor –

  Match to a stored reference and return link element.

• ShortReferenceInlineProcessor –

  Short form of reference: [google].

• ImageReferenceInlineProcessor –

  Match to a stored reference and return img element.

• ShortImageReferenceInlineProcessor –

  Short form of image reference: ![ref].

• AutolinkInlineProcessor –

  Return a link Element given an auto-link (<http://example/com>).

• AutomailInlineProcessor –

  Return a mailto link Element given an auto-mail link (<foo@example.com>).

Functions:

• build_inlinepatterns –

  Build the default set of inline patterns for Markdown.

• dequote –

  Remove quotes from around a string.

Attributes:

• NOIMG –

  Match not an image. Partial regular expression which matches if not preceded by !.

• BACKTICK_RE –

  Match backtick quoted string (`e=f()` or ``e=f("`")``).

• ESCAPE_RE –

  Match a backslash escaped character (\< or \*).

• EMPHASIS_RE –

  Match emphasis with an asterisk (*emphasis*).

• STRONG_RE –

  Match strong with an asterisk (**strong**).

• SMART_STRONG_RE –

  Match strong with underscore while ignoring middle word underscores (__smart__strong__).

• SMART_EMPHASIS_RE –

  Match emphasis with underscore while ignoring middle word underscores (_smart_emphasis_).

• SMART_STRONG_EM_RE –

  Match strong emphasis with underscores (__strong _em__).

• EM_STRONG_RE –

  Match emphasis strong with asterisk (***strongem*** or ***em*strong**).

• EM_STRONG2_RE –

  Match emphasis strong with underscores (___emstrong___ or ___em_strong__).

• STRONG_EM_RE –

  Match strong emphasis with asterisk (***strong**em*).

• STRONG_EM2_RE –

  Match strong emphasis with underscores (___strong__em_).

• STRONG_EM3_RE –

  Match strong emphasis with asterisk (**strong*em***).

• LINK_RE –

  Match start of in-line link ([text](url) or [text](<url>) or [text](url "title")).

• IMAGE_LINK_RE –

  Match start of in-line image link (![alttxt](url) or ![alttxt](<url>)).

• REFERENCE_RE –

  Match start of reference link ([Label][3]).

• IMAGE_REFERENCE_RE –

  Match start of image reference (![alt text][2]).

• NOT_STRONG_RE –

  Match a stand-alone * or _.

• AUTOLINK_RE –

  Match an automatic link (<http://www.example.com>).

• AUTOMAIL_RE –

  Match an automatic email link (<me@example.com>).

• HTML_RE –

  Match an HTML tag (<...>).

• ENTITY_RE –

  Match an HTML entity (& (decimal) or & (hex) or & (named)).

• LINE_BREAK_RE –

  Match two spaces at end of line.

NOIMG = r'(?<!\!)'