3
\2? @ s d Z ddlmZ ddlmZ ddlmZmZ ddlZddlZddl Z ddl
m Z ddl m
Z
dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZmZ dddgZe j dZ G dd de Z dd Z dd Z!dS )a
Python Markdown
===============
Python Markdown converts Markdown to HTML and can be used as a library or
called from the command line.
## Basic usage as a module:
import markdown
html = markdown.markdown(your_text_string)
See for more
information and instructions on how to extend the functionality of
Python Markdown. Read that before you try modifying this file.
## Authors and License
Started by [Manfred Stienstra](http://www.dwerg.net/). Continued and
maintained by [Yuri Takhteyev](http://www.freewisdom.org), [Waylan
Limberg](http://achinghead.com/) and [Artem Yunusov](http://blog.splyer.com).
Contact: markdown@freewisdom.org
Copyright 2007-2013 The Python Markdown Project (v. 1.7 and later)
Copyright 200? Django Software Foundation (OrderedDict implementation)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE for details).
)absolute_import)unicode_literals )version version_infoN)util)build_preprocessors)build_block_parser)build_treeprocessors)build_inlinepatterns)build_postprocessors) Extension)to_html_stringto_xhtml_stringMarkdownmarkdownmarkdownFromFileZMARKDOWNc @ s e Zd ZdZdZddddddZeeeeeedZdd d
d d d
ddddddddddgZ dd Z
dd Z d d Z g fd d Z
d d! Zd"d# Zd$d% Zd&d' Zd+d)d*Zd(S ),r zConvert Markdown to HTML.Zdivz[HTML_REMOVED] T)Zhtml_replacement_textZ
tab_lengthenable_attributesZsmart_emphasisZlazy_ol)htmlZhtml4Zhtml5Zxhtmlxhtml1Zxhtml5\`*_{}[]()>#+-.!c O s ddddg}d}x:|D ]2}|| |kr2|||| < |d7 }|t |krP qW x*| jj D ] \}}t| ||j|| qXW |jdd| _| jrd|krd| _g | _d | _d
| _ | j
i | _ t j
| _| j|jdg |jdi d | j|jdd | j d
S )a
Creates a new Markdown instance.
Keyword arguments:
* extensions: A list of extensions.
If they are of type string, the module mdx_name.py will be loaded.
If they are a subclass of markdown.Extension, they will be used
as-is.
* extension_configs: Configuration settingis for extensions.
* output_format: Format of output. Supported formats are:
* "xhtml1": Outputs XHTML 1.x. Default.
* "xhtml5": Outputs XHTML style tags of HTML 5
* "xhtml": Outputs latest supported version of XHTML (currently XHTML 1.1).
* "html4": Outputs HTML 4
* "html5": Outputs HTML style tags of HTML 5
* "html": Outputs latest supported version of HTML (currently HTML 4).
Note that it is suggested that the more specific formats ("xhtml1"
and "html4") be used as "xhtml" or "html" may change in the future
if it makes sense at that time.
* safe_mode: Disallow raw html. One of "remove", "replace" or "escape".
* html_replacement_text: Text used when safe_mode is set to "replace".
* tab_length: Length of tabs in the source. Default: 4
* enable_attributes: Enable the conversion of attributes. Default: True
* smart_emphasis: Treat `_connected_words_` intelligently Default: True
* lazy_ol: Ignore number of first item of ordered lists. Default: True
extensionsZextension_configsZ safe_mode
output_formatr r Fr T)r' configsr N)lenoption_defaultsitemssetattrgetZsafeModer registeredExtensionsZdocTypestripTopLevelTags build_parser
referencesr Z HtmlStash htmlStashregisterExtensionsset_output_formatreset)selfargskwargsposcargoptiondefault r@ build/lib/markdown/__init__.py__init__N s.
zMarkdown.__init__c C s6 t | | _t| | _t| | _t| | _t| | _ | S )z* Build the parser from the various parts. )
r
preprocessorsr parserr ZinlinePatternsr
treeprocessorsr postprocessors)r8 r@ r@ rA r2 s
zMarkdown.build_parserc C sl xf|D ]^}t |tjr*| j||j|g }t |trD|j| t q|dk rtd|j j
|j j f qW | S )a*
Register extensions with this instance of Markdown.
Keyword arguments:
* extensions: A list of extensions, which can either
be strings or objects. See the docstring on Markdown.
* configs: A dictionary mapping module names to config options.
Nz7Extension "%s.%s" must be of type: "markdown.Extension")
isinstancer string_typebuild_extensionr/ r
ZextendMarkdownglobals TypeError __class__
__module____name__)r8 r' r* extr@ r@ rA r5 s
zMarkdown.registerExtensionsc $ C sz t |}|jd}|dkr^||d d }|d| }dd |jdD }|jdd |D |}d |krxd jd
|g}y t|i i |jd d g}W n| tk
r d jd |g}y t|}W nJ tk
r } z,d
|||f }
|
f| jdd | _ W Y dd} ~ X nX Y nX y|j |j
S t k
rt } z4| jd }
d||
f }
|
f| jdd | _ W Y dd} ~ X nX dS )zBuild extension by name, then return the module.
The extension name may contain arguments as part of the string in the
following format: "extname(key1=value1,key2=value2)"
r r r Nc S s g | ]}|j d qS )=)split).0xr@ r@ rA
s z,Markdown.build_extension..,c S s g | ]\}}|j |j fqS r@ )strip)rR rS yr@ r@ rA rT s r% zmarkdown.extensionsr Zmdxz/Failed loading extension '%s' from '%s' or '%s'z%Failed to initiate extension '%s': %s) dictfindrQ updatejoin
__import__
rpartition ImportErrorr9 Z
makeExtensionr- AttributeError) r8 Zext_namer* r; Zext_argsZpairs module_namemoduleZmodule_name_old_styleemessager@ r@ rA rI s:
zMarkdown.build_extensionc C s | j j| | S )z# This gets called by the extension )r0 append)r8 extensionr@ r@ rA registerExtension s zMarkdown.registerExtensionc C s: | j j | jj x | jD ]}t|dr |j q W | S )zR
Resets all state variables so that we can start with a new text.
r7 )r4 r7 r3 clearr0 hasattr)r8 rf r@ r@ rA r7 s
zMarkdown.resetc C s |j | _y| j| j | _W nl tk
r } zPt| jj }|j d| jddj| d f }|f|j dd |_ W Y dd}~X nX | S )z/ Set the output format for the class instance. z+Invalid Output Format: "%s". Use one of %s."z", "r N)
lowerr( output_formats
serializerKeyErrorlistkeyssortr\ r9 )r8 formatrc Z
valid_formatsrd r@ r@ rA r6 s
zMarkdown.set_output_formatc C sx |j s dS ytj|}W n2 tk
rL } z| jd7 _ W Y dd}~X nX |jd| _x | jj D ]}|j | j| _qfW | j
j | jj }x(| j
j D ]}|j |}|dk r|}qW | j|}| jrPyB|jd| j t| j d }|jd| j } ||| j }W nB tk
rN |j jd| j r:d}ntd |j Y nX x | jj D ]}
|
j |}q\W |j S )
a
Convert markdown to serialized XHTML or HTML.
Keyword arguments:
* source: Source text as a Unicode string.
Markdown processing takes place in five steps:
1. A bunch of "preprocessors" munge the input text.
2. BlockParser() parses the high-level structural elements of the
pre-processed text into an ElementTree.
3. A bunch of "treeprocessors" are run against the ElementTree. One
such treeprocessor runs InlinePatterns against the ElementTree,
detecting inline markup.
4. Some post-processors are run against the text after the ElementTree
has been serialized into text.
5. The output is written to a string.
r) z/. -- Note: Markdown only accepts unicode input!N
z<%s> zz<%s />z4Markdown failed to strip top-level tags. Document=%r)rV r text_typeUnicodeDecodeErrorreasonrQ linesrC valuesrunrD Z
parseDocumentZgetrootrE rm r1 indexdoc_tagr+ rindex
ValueErrorendswithrF ) r8 sourcerc ZpreprootZ
treeprocessorZnewRootoutputstartendppr@ r@ rA convert s8
zMarkdown.convertNc C s |pd}|rJt |tjr*tj|d|d}ntj||}|j }|j n tj j }t |tj
sj|j |}|j d}| j
|}|rt |tjrtj|d|dd}|j| |j n tj|}||dd}|j| nB|j|d}ytjjj| W n" tk
r tjj| Y nX | S ) a? Converts a markdown file and returns the HTML as a unicode string.
Decodes the file using the provided encoding (defaults to utf-8),
passes the file content to markdown, and outputs the html to either
the provided stream or the file with provided name, using the same
encoding as the source file. The 'xmlcharrefreplace' error handler is
used when encoding the output.
**Note:** This is the only place that decoding and encoding of unicode
takes place in Python-Markdown. (All other code is unicode-in /
unicode-out.)
Keyword arguments:
* input: File object or path. Reads from stdin if `None`.
* output: File object or path. Writes to stdout if `None`.
* encoding: Encoding of input and output files. Defaults to utf-8.
zutf-8r)modeencodingu wxmlcharrefreplace)r errors)r )rG r rH codecsopen getreaderreadclosesysstdinru decodelstripr write getwriterencodestdoutbufferr` ) r8 inputr r Z
input_filetextr Z output_filewriterr@ r@ rA convertFile@ s8
zMarkdown.convertFile)NNN)rN rM __qualname____doc__r| r, r r rl Z
ESCAPED_CHARSrB r2 r5 rI rg r7 r6 r r r@ r@ r@ rA r 5 s0 ? .
Dc O s t ||}|j| S )a Convert a markdown string to HTML and return HTML as a unicode string.
This is a shortcut function for `Markdown` class to cover the most
basic use case. It initializes an instance of Markdown, loads the
necessary extensions and runs the parser on the given text.
Keyword arguments:
* text: Markdown formatted text as Unicode or ASCII string.
* Any arguments accepted by the Markdown class.
Returns: An HTML document as a string.
)r r )r r9 r: mdr@ r@ rA r s
c O s ddddg}d}x:| D ]2}|| |kr2|||| < |d7 }|t |krP qW tf |}|j|jdd|jdd|jdd dS )a Read markdown code from a file and write it to a file or a stream.
This is a shortcut function which initializes an instance of Markdown,
and calls the convertFile method rather than convert.
Keyword arguments:
* input: a file name or readable object.
* output: a file name or writable object.
* encoding: Encoding of input and output.
* Any arguments accepted by the Markdown class.
r r r' r r r N)r+ r r r/ )r9 r: r; r< r= r r@ r@ rA r s
)"r
__future__r r __version__r r r r Zloggingr) r rC r Zblockprocessorsr rE r
Zinlinepatternsr rF r r' r
Z serializersr r __all__Z getLoggerloggerobjectr r r r@ r@ r@ rA s*
X