pymdtools’s documentation

pymdtools 🐸

A small python module to manipulate markdown content. We use this library to manage a lot of content in markdown.

Wheel Status Latest Version License Build Status Documentation Status

Features

  • Read Markdown
  • Normalize markdown (it is more a beautifier)
  • Convert to html with multiple converter (python markdown, python mistune)
  • Convert to pdf with converter
  • manage links inside the markdown (change update links)
  • add some instructions (in html comment format):
    • variable or data easy to find
    • include file (like license or header)
    • share content between md file (define some shared paragraph)

License

The pymdtools is licensed under the terms of the MIT license and is available for free.

MIT License

Copyright (c) 2019 Florent Tournois

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Library API

Full API

Namespaces

Namespace pymdtools::common
Functions
Namespace pymdtools::instruction

Contents

Functions
Namespace pymdtools::mdfile

Contents

Namespace pymdtools::mdrender

Contents

Classes and Structs

Class Constant
Class Documentation
class Constant

Public Functions

__init__(self self, value value = None)
get_value(self self)
get(self self)
__get__(self self, _ignore_instance _ignore_instance, _ignore_owner _ignore_owner)
__set__(self self, _ignore_instance _ignore_instance, _ignore_value _ignore_value)

Public Members

value
Class FileContent
Inheritance Relationships
Base Type
Derived Type
Class Documentation
class FileContent

Subclassed by pymdtools.mdfile.MarkdownContent

Public Functions

__init__(self self, filename filename = None, content content = None, backup backup = True, encoding encoding = "utf-8")
content(self self)
content(self self, value value)
backup(self self)
backup(self self, value value)
save_needed(self self)
save_needed(self self, value value)
read(self self, filename filename = None, encoding encoding = "utf-8")
write(self self, filename filename = None, backup_ext backup_ext = ".bak", encoding encoding = "utf-8")
__repr__(self self)
__str__(self self)

Public Members

backup
content
full_filename
Class FileName
Inheritance Relationships
Derived Type
Class Documentation
class FileName

Subclassed by pymdtools.filetools.FileContent

Public Functions

__init__(self self, filename filename = None)
full_filename(self self)
full_filename(self self, value value)
filename(self self)
filename(self self, value value)
filename_path(self self)
filename_path(self self, value value)
filename_ext(self self)
filename_ext(self self, value value)
is_file(self self)
is_dir(self self)
__repr__(self self)
__str__(self self)

Public Members

full_filename
Class MarkdownConverter
Inheritance Relationships
Base Type
  • public object
Class Documentation
class MarkdownConverter

Public Functions

__init__(self self, options options)
convert(self self, html html)
process_tag(self self, node node, children_only children_only = False)
process_text(self self, text text)
__getattr__(self self, attr attr)
should_convert_tag(self self, tag tag)
indent(self self, text text, level level)
underline(self self, text text, pad_char pad_char)
convert_a(self self, el el, text text)
convert_b(self self, el el, text text)
convert_blockquote(self self, el el, text text)
convert_br(self self, el el, text text)
convert_em(self self, el el, text text)
convert_hn(self self, n n, el el, text text)
convert_i(self self, el el, text text)
convert_list(self self, el el, text text)
convert_li(self self, el el, text text)
convert_p(self self, el el, text text)
convert_strong(self self, el el, text text)
convert_img(self self, el el, text text)

Public Members

options

Public Static Attributes

pymdtools.markdownify.MarkdownConverter.convert_ul = convert_list
pymdtools.markdownify.MarkdownConverter.convert_ol = convert_list
class DefaultOptions

Subclassed by pymdtools.markdownify.MarkdownConverter.Options

Public Static Attributes

pymdtools.markdownify.MarkdownConverter.DefaultOptions.strip = None
pymdtools.markdownify.MarkdownConverter.DefaultOptions.convert = None
bool pymdtools.markdownify.MarkdownConverter.DefaultOptions.autolinks = True
pymdtools.markdownify.MarkdownConverter.DefaultOptions.heading_style = UNDERLINED
string pymdtools.markdownify.MarkdownConverter.DefaultOptions.bullets = '*+-'
Class MarkdownConverter::DefaultOptions
Nested Relationships

This class is a nested type of Class MarkdownConverter.

Inheritance Relationships
Derived Type
Class Documentation
class DefaultOptions

Subclassed by pymdtools.markdownify.MarkdownConverter.Options

Public Static Attributes

pymdtools.markdownify.MarkdownConverter.DefaultOptions.strip = None
pymdtools.markdownify.MarkdownConverter.DefaultOptions.convert = None
bool pymdtools.markdownify.MarkdownConverter.DefaultOptions.autolinks = True
pymdtools.markdownify.MarkdownConverter.DefaultOptions.heading_style = UNDERLINED
string pymdtools.markdownify.MarkdownConverter.DefaultOptions.bullets = '*+-'
Class MarkdownConverter::Options
Nested Relationships

This class is a nested type of Class MarkdownConverter.

Inheritance Relationships
Base Type
Class Documentation
class Options
Class MarkdownContent
Inheritance Relationships
Base Type
Class Documentation
class MarkdownContent

Public Functions

__init__(self self, filename filename = None, content content = None, backup backup = True, encoding encoding = "unknown", kwargs kwargs)
__setitem__(self self, key key, item item)
__getitem__(self self, key key)
__delitem__(self self, key key)
has_key(self self, k k)
keys(self self)
values(self self)
items(self self)
__contains__(self self, item item)
__iter__(self self)
title(self self)
title(self self, value value)
toc(self self)
set_include_file(self self, filename filename)
del_include_file(self self, filename filename)
beautify(self self)
process_tags(self self)

Public Members

content
Class MdRenderer
Inheritance Relationships
Base Type
  • public Renderer
Class Documentation
class MdRenderer

Public Functions

get_block(text text)
newline(self self)
text(self self, text text)
linebreak(self self)
hrule(self self)
header(self self, text text, level level, raw raw = None)
paragraph(self self, text text)
list(self self, text text, ordered ordered = True)
list_item(self self, text text)
block_code(self self, code code, lang lang = None)
block_quote(self self, text text)
emphasis(self self, text text)
double_emphasis(self self, text text)
strikethrough(self self, text text)
codespan(self self, text text)
image(self self, src src, title title, text text)
table(self self, header header, body body)
table_row(self self, content content)
table_cell(self self, content content, flags flags)
footnote_ref(self self, key key, index index)
footnote_item(self self, key key, text text)
footnotes(self self, text text)
Class BlockGrammar
Inheritance Relationships
Base Type
  • public object
Class Documentation
class BlockGrammar

Grammars for block level tokens.

Public Static Attributes

pymdtools.mistunege.BlockGrammar.def_links= re.compile( r'^ *[([^^]]+)]: *' # [key]: r'<?([^s>]+)>?' # <link> or link r'(?: +["(]([^n]+)[")])? *(?:n+|$)' )
pymdtools.mistunege.BlockGrammar.def_footnotes= re.compile( r'^[^([^]]+)]: *(' r'[^n]*(?:n+|$)' # [^key]: r'(?: {1,}[^n]*(?:n+|$))*' r')' )
pymdtools.mistunege.BlockGrammar.newline = re.compile(r'^n+')
pymdtools.mistunege.BlockGrammar.block_code = re.compile(r'^( {4}[^n]+n*)+')
pymdtools.mistunege.BlockGrammar.fences= re.compile( r'^ *(`{3,}|~{3,}) *(S+)? *n' # ```lang r'([sS]+?)s*' r'1 *(?:n+|$)' # ``` )
pymdtools.mistunege.BlockGrammar.hrule = re.compile(r'^ {0,3}[-*_](?: *[-*_]){2,} *(?:n+|$)')
pymdtools.mistunege.BlockGrammar.heading = re.compile(r'^ *(#{1,6}) *([^n]+?) *#* *(?:n+|$)')
pymdtools.mistunege.BlockGrammar.lheading = re.compile(r'^([^n]+)n *(=|-)+ *(?:n+|$)')
pymdtools.mistunege.BlockGrammar.block_quote = re.compile(r'^( *>[^n]+(n[^n]+)*n*)+')
pymdtools.mistunege.BlockGrammar.list_block= re.compile( r'^( *)([*+-]|d+.) [sS]+?' r'(?:' r'n+(?=1?(?:[-*_] *){3,}(?:n+|$))' # hrule r'|n+(?=%s)' # def links r'|n+(?=%s)' # def footnotes r'|n{2,}' r'(?! )' r'(?!1(?:[*+-]|d+.) )n*' r'|' r's*$)' % ( _pure_pattern(def_links), _pure_pattern(def_footnotes), ) )
pymdtools.mistunege.BlockGrammar.list_item= re.compile( r'^(( *)(?:[*+-]|d+.) [^n]*' r'(?:n(?!2(?:[*+-]|d+.) )[^n]*)*)', flags=re.M )
pymdtools.mistunege.BlockGrammar.list_bullet = re.compile(r'^ *(?:[*+-]|d+.) +')
pymdtools.mistunege.BlockGrammar.paragraph= re.compile( r'^((?:[^n]+n?(?!' r'%s|%s|%s|%s|%s|%s|%s|%s|%s' r'))+)n*' % ( _pure_pattern(fences).replace(r'1', r'2'), _pure_pattern(list_block).replace(r'1', r'3'), _pure_pattern(hrule), _pure_pattern(heading), _pure_pattern(lheading), _pure_pattern(block_quote), _pure_pattern(def_links), _pure_pattern(def_footnotes), '<' + _block_tag, ) )
pymdtools.mistunege.BlockGrammar.block_html= re.compile( r'^ *(?:%s|%s|%s) *(?:n{2,}|s*$)' % ( r'<!--[sS]*?-->', r'<(%s)((?:%s)*?)>([sS]*?)</1>' % (_block_tag, _valid_attr), r'<%s(?:%s)*?s*/?>' % (_block_tag, _valid_attr), ) )
pymdtools.mistunege.BlockGrammar.table= re.compile( r'^ *|(.+)n *|( *[-:]+[-| :]*)n((?: *|.*(?:n|$))*)n*' )
pymdtools.mistunege.BlockGrammar.nptable= re.compile( r'^ *(S.*|.*)n *([-:]+ *|[-| :]*)n((?:.*|.*(?:n|$))*)n*' )
pymdtools.mistunege.BlockGrammar.text = re.compile(r'^[^n]+')
Class BlockLexer
Inheritance Relationships
Base Type
  • public object
Class Documentation
class BlockLexer

Block level lexer for block grammars.

Public Functions

__init__(self self, rules rules = None, kwargs kwargs)
__call__(self self, text text, rules rules = None)
parse(self self, text text, rules rules = None)
parse_newline(self self, m m)
parse_block_code(self self, m m)
parse_fences(self self, m m)
parse_heading(self self, m m)
parse_lheading(self self, m m)

Parse setext heading.

parse_hrule(self self, m m)
parse_list_block(self self, m m)
parse_block_quote(self self, m m)
parse_def_footnotes(self self, m m)
parse_table(self self, m m)
parse_nptable(self self, m m)
parse_block_html(self self, m m)
parse_paragraph(self self, m m)
parse_text(self self, m m)

Public Members

tokens
def_footnotes
rules

Public Static Attributes

pymdtools.mistunege.BlockLexer.grammar_class = BlockGrammar
list pymdtools.mistunege.BlockLexer.default_rules= [ 'newline', 'hrule', 'block_code', 'fences', 'heading', 'nptable', 'lheading', 'block_quote', 'list_block', 'block_html', 'def_links', 'def_footnotes', 'table', 'paragraph', 'text' ]
tuple pymdtools.mistunege.BlockLexer.list_rules= ( 'newline', 'block_code', 'fences', 'lheading', 'hrule', 'block_quote', 'list_block', 'block_html', 'text', )
tuple pymdtools.mistunege.BlockLexer.footnote_rules= ( 'newline', 'block_code', 'fences', 'heading', 'nptable', 'lheading', 'hrule', 'block_quote', 'list_block', 'block_html', 'table', 'paragraph', 'text' )
Class InlineGrammar
Inheritance Relationships
Base Type
  • public object
Class Documentation
class InlineGrammar

Grammars for inline level tokens.

Public Functions

hard_wrap(self self)

Grammar for hard wrap linebreak. You don't need to add two
spaces at the end of a line.

Public Static Attributes

pymdtools.mistunege.InlineGrammar.escape = re.compile(r'^\([\`*{}[]()#+-.!_>~|])')
pymdtools.mistunege.InlineGrammar.inline_html= re.compile( r'^(?:%s|%s|%s)' % ( r'<!--[sS]*?-->', r'<(w+%s)((?:%s)*?)s*>([sS]*?)</1>' % (_valid_end, _valid_attr), r'<w+%s(?:%s)*?s*/?>' % (_valid_end, _valid_attr), ) )
pymdtools.mistunege.InlineGrammar.autolink = re.compile(r'^<([^ >]+(@|:)[^ >]+)>')
pymdtools.mistunege.InlineGrammar.link= re.compile( r'^!?[(' r'(?:[[^^]]*]|[^[]]|](?=[^[]*]))*' r')](' r')' )
pymdtools.mistunege.InlineGrammar.reflink= re.compile( r'^!?[(' r'(?:[[^^]]*]|[^[]]|](?=[^[]*]))*' r')]s*[([^^]]*)]' )
pymdtools.mistunege.InlineGrammar.nolink = re.compile(r'^!?[((?:[[^]]*]|[^[]])*)]')
pymdtools.mistunege.InlineGrammar.url = re.compile()
pymdtools.mistunege.InlineGrammar.double_emphasis= re.compile( r'^_{2}([sS]+?)_{2}(?!_)' # __word__ r'|' r'^*{2}([sS]+?)*{2}(?!*)' # **word** )
pymdtools.mistunege.InlineGrammar.emphasis= re.compile( r'^b_((?:__|[^_])+?)_b' # _word_ r'|' r'^*((?:**|[^*])+?)*(?!*)' # *word* )
pymdtools.mistunege.InlineGrammar.code = re.compile(r'^(`+)s*([sS]*?[^`])s*1(?!`)')
pymdtools.mistunege.InlineGrammar.linebreak = re.compile(r'^ {2,}n(?!s*$)')
pymdtools.mistunege.InlineGrammar.strikethrough = re.compile(r'^~~(?=S)([sS]*?S)~~')
pymdtools.mistunege.InlineGrammar.footnote = re.compile(r'^[^([^]]+)]')
pymdtools.mistunege.InlineGrammar.text = re.compile(r'^[sS]+?(?=[\<![_*`~]|https?://| {2,}n|$)')
Class InlineLexer
Inheritance Relationships
Base Type
  • public object
Class Documentation
class InlineLexer

Inline level lexer for inline grammars.

Public Functions

__init__(self self, renderer renderer, rules rules = None, kwargs kwargs)
__call__(self self, text text, rules rules = None)
setup(self self, links links, footnotes footnotes)
output(self self, text text, rules rules = None)
output_escape(self self, m m)
output_url(self self, m m)
output_inline_html(self self, m m)
output_footnote(self self, m m)
output_double_emphasis(self self, m m)
output_emphasis(self self, m m)
output_code(self self, m m)
output_linebreak(self self, m m)
output_strikethrough(self self, m m)
output_text(self self, m m)

Public Members

renderer
footnotes
footnote_index
rules
line_match
line_started

Public Static Attributes

pymdtools.mistunege.InlineLexer.grammar_class = InlineGrammar
list pymdtools.mistunege.InlineLexer.default_rules= [ 'escape', 'inline_html', 'autolink', 'url', 'footnote', 'link', 'reflink', 'nolink', 'double_emphasis', 'emphasis', 'code', 'linebreak', 'strikethrough', 'text', ]
list pymdtools.mistunege.InlineLexer.inline_html_rules= [ 'escape', 'autolink', 'url', 'link', 'reflink', 'nolink', 'double_emphasis', 'emphasis', 'code', 'linebreak', 'strikethrough', 'text', ]
Class Markdown
Inheritance Relationships
Base Type
  • public object
Class Documentation
class Markdown

The Markdown parser.

:param renderer: An instance of ``Renderer``.
:param inline: An inline lexer class or instance.
:param block: A block lexer class or instance.

Public Functions

__init__(self self, renderer renderer = None, inline inline = None, block block = None, kwargs kwargs)
__call__(self self, text text)
render(self self, text text)

Render the Markdown text.

:param text: markdown formatted text content.

parse(self self, text text)
pop(self self)
peek(self self)
output(self self, text text, rules rules = None)
tok(self self)
tok_text(self self)
output_newline(self self)
output_hrule(self self)
output_heading(self self)
output_code(self self)
output_table(self self)
output_block_quote(self self)
output_list(self self)
output_list_item(self self)
output_loose_item(self self)
output_footnote(self self)
output_close_html(self self)
output_open_html(self self)
output_paragraph(self self)
output_text(self self)

Public Members

renderer
inline
block
footnotes
tokens
token
Class Renderer
Inheritance Relationships
Base Type
  • public object
Class Documentation
class Renderer

The default HTML renderer for rendering Markdown.

Public Functions

__init__(self self, kwargs kwargs)
placeholder(self self)

Returns the default, empty output value for the renderer.

All renderer methods use the '+=' operator to append to this value.
Default is a string so rendering HTML can build up a result string with
the rendered Markdown.

Can be overridden by Renderer subclasses to be types like an empty
list, allowing the renderer to create a tree-like structure to
represent the document (which can then be reprocessed later into a
separate format like docx or pdf).

block_code(self self, code code, lang lang = None)

Rendering block level code. ``pre > code``.

:param code: text content of the code block.
:param lang: language of the given code.

block_quote(self self, text text)

Rendering <blockquote> with the given text.

:param text: text content of the blockquote.

block_html(self self, html html)

Rendering block level pure html content.

:param html: text content of the html snippet.

header(self self, text text, level level, raw raw = None)

Rendering header/heading tags like ``<h1>`` ``<h2>``.

:param text: rendered text content for the header.
:param level: a number for the header level, for example: 1.
:param raw: raw text content of the header.

hrule(self self)

Rendering method for ``<hr>`` tag.

list(self self, body body, ordered ordered = True)

Rendering list tags like ``<ul>`` and ``<ol>``.

:param body: body contents of the list.
:param ordered: whether this list is ordered or not.

list_item(self self, text text)

Rendering list item snippet. Like ``<li>``.

paragraph(self self, text text)

Rendering paragraph tags. Like ``<p>``.

table(self self, header header, body body)

Rendering table element. Wrap header and body in it.

:param header: header part of the table.
:param body: body part of the table.

table_row(self self, content content)

Rendering a table row. Like ``<tr>``.

:param content: content of current table row.

table_cell(self self, content content, flags flags)

Rendering a table cell. Like ``<th>`` ``<td>``.

:param content: content of current table cell.
:param header: whether this is header or not.
:param align: align of current table cell.

double_emphasis(self self, text text)

Rendering **strong** text.

:param text: text content for emphasis.

emphasis(self self, text text)

Rendering *emphasis* text.

:param text: text content for emphasis.

codespan(self self, text text)

Rendering inline `code` text.

:param text: text content for inline code.

linebreak(self self)

Rendering line break like ``<br>``.

strikethrough(self self, text text)

Rendering ~~strikethrough~~ text.

:param text: text content for strikethrough.

text(self self, text text)

Rendering unformatted text.

:param text: text content.

escape(self self, text text)

Rendering escape sequence.

:param text: text content.


Rendering a given link or email address.

:param link: link content or email address.
:param is_email: whether this is an email or not.


Rendering a given link with content and title.

:param link: href link for ``<a>`` tag.
:param title: title content for `title` attribute.
:param text: text content for description.

image(self self, src src, title title, text text)

Rendering a image with title and text.

:param src: source link of the image.
:param title: title text of the image.
:param text: alt text of the image.

inline_html(self self, html html)

Rendering span level pure html content.

:param html: text content of the html snippet.

newline(self self)

Rendering newline element.

footnote_ref(self self, key key, index index)

Rendering the ref anchor of a footnote.

:param key: identity key for the footnote.
:param index: the index count of current footnote.

footnote_item(self self, key key, text text)

Rendering a footnote item.

:param key: identity key for the footnote.
:param text: text content of the footnote.

footnotes(self self, text text)

Wrapper for all footnotes.

:param text: contents of all footnotes.

Public Members

options

Functions

Function pymdtools::common::__get_this_filename
Function Documentation
pymdtools.common.__get_this_filename()
Function pymdtools::common::apply_function_in_folder
Function Documentation
pymdtools.common.apply_function_in_folder(folder folder, process process, filename_ext filename_ext = ".md")
Function pymdtools::common::check_create_folder
Function Documentation
pymdtools.common.check_create_folder(folder folder)
Function pymdtools::common::check_folder
Function Documentation
pymdtools.common.check_folder(folder folder)
Function pymdtools::common::check_is_file_and_correct_path
Function Documentation
pymdtools.common.check_is_file_and_correct_path(filename filename, filename_ext filename_ext = None)
Function pymdtools::common::check_len
Function Documentation
pymdtools.common.check_len(obj obj, length length = 1)
Function pymdtools::common::copytree
Function Documentation
pymdtools.common.copytree(src src, dst dst, symlinks symlinks = False, ignore ignore = None)
Function pymdtools::common::create_backup
Function Documentation
pymdtools.common.create_backup(filename filename, backup_ext backup_ext = ".bak")
Function pymdtools::common::filename_ext_to
Function Documentation
pymdtools.common.filename_ext_to(filename filename, ext ext)
Function pymdtools::common::filename_ext_to_chm
Function Documentation
pymdtools.common.filename_ext_to_chm(filename filename)
Function pymdtools::common::filename_ext_to_hhc
Function Documentation
pymdtools.common.filename_ext_to_hhc(filename filename)
Function pymdtools::common::filename_ext_to_hhk
Function Documentation
pymdtools.common.filename_ext_to_hhk(filename filename)
Function pymdtools::common::filename_ext_to_hhp
Function Documentation
pymdtools.common.filename_ext_to_hhp(filename filename)
Function pymdtools::common::filename_ext_to_html
Function Documentation
pymdtools.common.filename_ext_to_html(filename filename)
Function pymdtools::common::filename_ext_to_md
Function Documentation
pymdtools.common.filename_ext_to_md(filename filename)
Function pymdtools::common::filename_ext_to_pdf
Function Documentation
pymdtools.common.filename_ext_to_pdf(filename filename)
Function pymdtools::common::get_file_content
Function Documentation
pymdtools.common.get_file_content(filename filename, encoding encoding = "utf-8")
Function pymdtools::common::get_file_encoding
Function Documentation
pymdtools.common.get_file_encoding(filename filename)
Function pymdtools::common::get_flat_filename
Function Documentation
pymdtools.common.get_flat_filename(filename filename, replacement replacement = "_")
Function pymdtools::common::get_new_temp_dir
Function Documentation
pymdtools.common.get_new_temp_dir()
Function pymdtools::common::get_today
Function Documentation
pymdtools.common.get_today()
Function pymdtools::common::get_valid_filename
Function Documentation
pymdtools.common.get_valid_filename(filename filename)
Function pymdtools::common::handle_exception
Function Documentation
pymdtools.common.handle_exception(action_desc action_desc, kwargs_print_name kwargs_print_name)
Function pymdtools::common::is_binary_file
Function Documentation
pymdtools.common.is_binary_file(source_path source_path)
Function pymdtools::common::limit_str
Function Documentation
pymdtools.common.limit_str(value value, limit limit, char_split char_split, min_last_word min_last_word = 2)
Function pymdtools::common::number_of_subfolder
Function Documentation
pymdtools.common.number_of_subfolder(filename filename)
Function pymdtools::common::path_to_url
Function Documentation
pymdtools.common.path_to_url(path path, remove_accent remove_accent = True)
Function pymdtools::common::print_conv
Function Documentation
pymdtools.common.print_conv(text text, coding_in coding_in = 'utf-8', coding_out coding_out = None)
Function pymdtools::common::search_for_file
Function Documentation
pymdtools.common.search_for_file(file_wanted file_wanted, start_points start_points, relative_paths relative_paths, nb_up_path nb_up_path = 4)
Function pymdtools::common::set_correct_path
Function Documentation
pymdtools.common.set_correct_path(folder_or_file_name folder_or_file_name)
Function pymdtools::common::set_file_content
Function Documentation
pymdtools.common.set_file_content(filename filename, content content, encoding encoding = "utf-8", bom bom = True)
Function pymdtools::common::simple_decorator
Function Documentation
pymdtools.common.simple_decorator(decorator decorator)
Function pymdtools::common::slugify
Function Documentation
pymdtools.common.slugify(value value, allow_unicode allow_unicode = False)
Function pymdtools::common::static
Function Documentation
pymdtools.common.static(kwargs kwargs)
Function pymdtools::common::str_to_ascii
Function Documentation
pymdtools.common.str_to_ascii(value value)
Function pymdtools::common::strip_first_and_last_space
Function Documentation
pymdtools.common.strip_first_and_last_space(text text)
Function pymdtools::filetools::__get_this_filename
Function Documentation
pymdtools.filetools.__get_this_filename()
Function pymdtools::filetools::get_template_file
Function Documentation
pymdtools.filetools.get_template_file(filename filename, start_folder start_folder = None)
Function pymdtools::filetools::get_template_files_in_folder
Function Documentation
pymdtools.filetools.get_template_files_in_folder(folder folder)
Function pymdtools::instruction::__get_this_filename
Function Documentation
pymdtools.instruction.__get_this_filename()
Function pymdtools::instruction::del_include_file_to_md_text
Function Documentation
pymdtools.instruction.del_include_file_to_md_text(text text, filename filename)
Function pymdtools::instruction::del_var_to_md_text
Function Documentation
pymdtools.instruction.del_var_to_md_text(text text, var_name var_name)
Function pymdtools::instruction::get_file_content_to_include
Function Documentation
pymdtools.instruction.get_file_content_to_include(filename filename, search_folder search_folder = None, kwargs kwargs)
Function pymdtools::instruction::get_include_file_list
Function Documentation
pymdtools.instruction.get_include_file_list(text text)
Function pymdtools::instruction::get_refs_around_md_file
Function Documentation
pymdtools.instruction.get_refs_around_md_file(filename filename, filename_ext filename_ext = ".md", previous_refs previous_refs = None, depth_up depth_up = 1, depth_down depth_down = -1)
Function pymdtools::instruction::get_refs_from_md_directory
Function Documentation
pymdtools.instruction.get_refs_from_md_directory(folder folder, filename_ext filename_ext = ".md", previous_refs previous_refs = None, depth depth = -1)
Function pymdtools::instruction::get_refs_from_md_file
Function Documentation
pymdtools.instruction.get_refs_from_md_file(filename filename, filename_ext filename_ext = ".md", previous_refs previous_refs = None)
Function pymdtools::instruction::get_refs_from_md_text
Function Documentation
pymdtools.instruction.get_refs_from_md_text(text text, previous_refs previous_refs = None)
Function pymdtools::instruction::get_refs_other
Function Documentation
pymdtools.instruction.get_refs_other(refs refs = None, filename_ext filename_ext = ".md", kwargs kwargs)
Function pymdtools::instruction::get_title_from_md_text
Function Documentation
pymdtools.instruction.get_title_from_md_text(text text, return_match return_match = False)
Function pymdtools::instruction::get_vars_from_md_file
Function Documentation
pymdtools.instruction.get_vars_from_md_file(filename filename, filename_ext filename_ext = ".md", previous_vars previous_vars = None)
Function pymdtools::instruction::get_vars_from_md_text
Function Documentation
pymdtools.instruction.get_vars_from_md_text(text text, previous_vars previous_vars = None)
Function pymdtools::instruction::include_files_to_md_file
Function Documentation
pymdtools.instruction.include_files_to_md_file(filename filename, backup_option backup_option = True, filename_ext filename_ext = ".md")
Function pymdtools::instruction::include_files_to_md_text
Function Documentation
pymdtools.instruction.include_files_to_md_text(text text, include_file_re include_file_re = __include_file_re__, error_if_no_file error_if_no_file = True, kwargs kwargs)
Function pymdtools::instruction::include_refs_to_md_file
Function Documentation
pymdtools.instruction.include_refs_to_md_file(filename filename, refs refs, backup_option backup_option = True, filename_ext filename_ext = ".md", begin_include_re begin_include_re = __begin_include_re__, end_include_re end_include_re = __end_include_re__, error_if_no_key error_if_no_key = True)
Function pymdtools::instruction::include_refs_to_md_text
Function Documentation
pymdtools.instruction.include_refs_to_md_text(text text, refs_include refs_include, begin_include_re begin_include_re = __begin_include_re__, end_include_re end_include_re = __end_include_re__, error_if_no_key error_if_no_key = True)
Function pymdtools::instruction::include_vars_to_md_file
Function Documentation
pymdtools.instruction.include_vars_to_md_file(filename filename, text_vars text_vars, backup_option backup_option = True, filename_ext filename_ext = ".md", begin_var_re begin_var_re = __begin_var_re__, end_var_re end_var_re = __end_var_re__, error_if_var_not_found error_if_var_not_found = True)
Function pymdtools::instruction::include_vars_to_md_text
Function Documentation
pymdtools.instruction.include_vars_to_md_text(text text, vars_include vars_include, begin_var_re begin_var_re = __begin_var_re__, end_var_re end_var_re = __end_var_re__, error_if_var_not_found error_if_var_not_found = True)
Function pymdtools::instruction::refs_in_md_text
Function Documentation
pymdtools.instruction.refs_in_md_text(text text, begin_include_re begin_include_re = __begin_include_re__)
Function pymdtools::instruction::search_include_refs_to_md_file
Function Documentation
pymdtools.instruction.search_include_refs_to_md_file(filename filename, backup_option backup_option = True, filename_ext filename_ext = ".md", depth_up depth_up = 1, depth_down depth_down = -1)

Search and include reference to the markdown text
    @warning All the reference must be defined

    Depth down parameter :
                    - -1-> every subfolder.
                    -  0-> the current level
                    -  n-> (with n>0) n subfolder level of the folder

    @type filename: string
    @param filename The name and path of the file to work with.
                    This file is supposed to be a markdown file.

    @type backup_option: boolean
    @param backup_option This parameter is set to true by default.
                            If the backup option is set, then a file
                            named filename.bak will be created.

    @type filename_ext: string
    @param filename_ext This parameter the markdown extension
                        for the filename.

    @type depth_up: integer
    @param depth_up the number of upper folder to search for.

    @type depth_down: integer
    @param depth_down the depth to search for.

Function pymdtools::instruction::search_include_vars_to_md_file
Function Documentation
pymdtools.instruction.search_include_vars_to_md_file(filename filename, backup_option backup_option = True, filename_ext filename_ext = ".md")
Function pymdtools::instruction::search_include_vars_to_md_text
Function Documentation
pymdtools.instruction.search_include_vars_to_md_text(text text)
Function pymdtools::instruction::set_include_file_to_md_text
Function Documentation
pymdtools.instruction.set_include_file_to_md_text(text text, filename filename)
Function pymdtools::instruction::set_title_in_md_text
Function Documentation
pymdtools.instruction.set_title_in_md_text(text text, new_title new_title)
Function pymdtools::instruction::set_var_to_md_text
Function Documentation
pymdtools.instruction.set_var_to_md_text(text text, var_name var_name, value value)
Function pymdtools::instruction::strip_xml_comment
Function Documentation
pymdtools.instruction.strip_xml_comment(text text)
Function pymdtools::markdownify::_todict
Function Documentation
pymdtools.markdownify._todict(obj obj)
Function pymdtools::markdownify::escape
Function Documentation
pymdtools.markdownify.escape(text text)
Function pymdtools::markdownify::markdownify
Function Documentation
pymdtools.markdownify.markdownify(html html, options options)
Function pymdtools::markdownify::strip_first_last_lf_large
Function Documentation
pymdtools.markdownify.strip_first_last_lf_large(text text)
Function pymdtools::markdownify::strip_first_last_space
Function Documentation
pymdtools.markdownify.strip_first_last_space(text text)
Function pymdtools::markdownify::strip_first_last_space_large
Function Documentation
pymdtools.markdownify.strip_first_last_space_large(text text)
Function pymdtools::mdcommon::get_domain_name
Function Documentation
pymdtools.mdcommon.get_domain_name(url url)
Function pymdtools::mdcommon::move_base_path_in_md_text
Function Documentation
pymdtools.mdcommon.move_base_path_in_md_text(text_md text_md, mv_base_path mv_base_path)
Function pymdtools::mdcommon::search_link_in_md_text
Function Documentation
pymdtools.mdcommon.search_link_in_md_text(text text, previous_links previous_links = None)
Function pymdtools::mdcommon::search_link_in_md_text_json
Function Documentation
pymdtools.mdcommon.search_link_in_md_text_json(text_md text_md)
Function pymdtools::mdcommon::sub_string_name_by_ref_md
Function Documentation
pymdtools.mdcommon.sub_string_name_by_ref_md(unused_dummy unused_dummy, link link)
Function pymdtools::mdcommon::update_link_in_md_text
Function Documentation
pymdtools.mdcommon.update_link_in_md_text(text_md text_md, name name, new_link new_link)
Function pymdtools::mdcommon::update_links_in_md_text
Function Documentation
pymdtools.mdcommon.update_links_in_md_text(text_md text_md, links links)
Function pymdtools::mdtopdf::__get_this_filename
Function Documentation
pymdtools.mdtopdf.__get_this_filename()
Function pymdtools::mdtopdf::check_odd_pages
Function Documentation
pymdtools.mdtopdf.check_odd_pages(filename filename)
Function pymdtools::mdtopdf::convert_html_to_pdf
Function Documentation
pymdtools.mdtopdf.convert_html_to_pdf(filename filename, filename_ext filename_ext = ".html", kwargs kwargs)
Function pymdtools::mdtopdf::convert_md_to_html
Function Documentation
pymdtools.mdtopdf.convert_md_to_html(filename filename, layout layout = "jasonm23-swiss", filename_ext filename_ext = ".md", encoding encoding = "utf-8", path_dest path_dest = None, converter converter = None)
Function pymdtools::mdtopdf::convert_md_to_pdf
Function Documentation
pymdtools.mdtopdf.convert_md_to_pdf(filename filename, filename_ext filename_ext = ".md", kwargs kwargs)

This function take a file, load the content, create a pdf
with the same name.

@type filename: string
@param filename: The name and path of the file to work with.
                 This file is supposed to be a markdown file.

@type filename_ext: string
@param filename_ext: This parameter the markdown extension
                     for the filename.

@return nothing

Function pymdtools::mdtopdf::converter_md_to_html_markdown
Function Documentation
pymdtools.mdtopdf.converter_md_to_html_markdown(text text)
Function pymdtools::mdtopdf::converter_md_to_html_mistune
Function Documentation
pymdtools.mdtopdf.converter_md_to_html_mistune(text text)
Function pymdtools::mdtopdf::find_wk_html_to_pdf
Function Documentation
pymdtools.mdtopdf.find_wk_html_to_pdf()
Function pymdtools::mdtopdf::get_md_to_html_converter
Function Documentation
pymdtools.mdtopdf.get_md_to_html_converter(converter_name converter_name)
Function pymdtools::mdtopdf::pdf_features
Function Documentation
pymdtools.mdtopdf.pdf_features(filename filename, filename_ext filename_ext = ".pdf", kwargs kwargs)
Function pymdtools::mistunege::_keyify
Function Documentation
pymdtools.mistunege._keyify(key key)
Function pymdtools::mistunege::_pure_pattern
Function Documentation
pymdtools.mistunege._pure_pattern(regex regex)
Function pymdtools::mistunege::escape
Function Documentation
pymdtools.mistunege.escape(text text, quote quote = False, smart_amp smart_amp = True)

Replace special characters "&", "<" and ">" to HTML-safe sequences.

The original cgi.escape will always escape "&", but you can control
this one for a smart escape amp.

:param quote: if set to True, " and ' will be escaped.
:param smart_amp: if set to False, & will always be escaped.

Function pymdtools::mistunege::markdown
Function Documentation
pymdtools.mistunege.markdown(text text, escape escape = True, kwargs kwargs)

Render markdown formatted text to html.

:param text: markdown formatted text content.
:param escape: if set to False, all html tags will not be escaped.
:param use_xhtml: output with xhtml tags.
:param hard_wrap: if set to True, it will use the GFM line breaks feature.
:param parse_block_html: parse text only in block level html.
:param parse_inline_html: parse text only in inline level html.

Function pymdtools::mistunege::preprocessing
Function Documentation
pymdtools.mistunege.preprocessing(text text, tab tab = 4)
Function pymdtools::normalize::md_beautifier
Function Documentation
pymdtools.normalize.md_beautifier(text text)
Function pymdtools::normalize::md_file_beautifier
Function Documentation
pymdtools.normalize.md_file_beautifier(filename filename, backup_option backup_option = True, filename_ext filename_ext = ".md")

This function take a file, load the content, create a backup (if needed)
and do some change in the file which is supposed to be a markdown file.
Then saved the new file with the same filename. The goal is to beautify
the markdown file.

@type filename: string
@param filename: The name and path of the file to work with. This file is
                 supposed to be a markdown file.

@type backup_option: boolean
@param backup_option: This parameter is set to true by default.
                      If the backup option is set,
                      then a file named filename.bak will be created.

@type filename_ext: string
@param filename_ext: This parameter the markdown extension
                     for the filename.

@return nothing

Function pymdtools::translate::__get_this_filename
Function Documentation
pymdtools.translate.__get_this_filename()

Return the filename of this script with frozen compatibility
@return the filename of THIS script.

Function pymdtools::translate::__get_this_folder
Function Documentation
pymdtools.translate.__get_this_folder()

Return the folder of this script with frozen compatibility
@return the folder of THIS script.

Function pymdtools::translate::_translation_parameter
Function Documentation
pymdtools.translate._translation_parameter()
Function pymdtools::translate::eu_lang_list
Function Documentation
pymdtools.translate.eu_lang_list()
Function pymdtools::translate::get_localedir
Function Documentation
pymdtools.translate.get_localedir(domain_name domain_name = None, folder folder = None)
Function pymdtools::translate::get_translation
Function Documentation
pymdtools.translate.get_translation(lang lang, domain_name domain_name, folder folder = None)
Function pymdtools::translate::N_
Function Documentation
pymdtools.translate.N_(message message)
Function pymdtools::translate::translate
Function Documentation
pymdtools.translate.translate(obj obj, lang lang, domain_name domain_name)
Function pymdtools::translate::translate_dict
Function Documentation
pymdtools.translate.translate_dict(obj obj, lang lang, domain_name domain_name)
Function pymdtools::translate::translate_list
Function Documentation
pymdtools.translate.translate_list(obj obj, lang lang, domain_name domain_name)
Function pymdtools::translate::translate_md
Function Documentation
pymdtools.translate.translate_md(md_text md_text, src src = "fr", dest dest = "en")
Function pymdtools::translate::translate_str
Function Documentation
pymdtools.translate.translate_str(message message, lang lang, domain_name domain_name)
Function pymdtools::translate::translate_txt
Function Documentation
pymdtools.translate.translate_txt(text text, src src = "fr", dest dest = "en")

Variables

Variable pymdtools::__all__
Variable Documentation
list pymdtools.__all__= [ 'print_conv', 'markdown_file_beautifier', 'convert_md_to_pdf', 'search_include_refs_to_md_file',]
Variable pymdtools::__author__
Variable Documentation
string pymdtools.__author__ = "Florent Tournois"
Variable pymdtools::__credits__
Variable Documentation
list pymdtools.__credits__ = ["Arnaud Boidard"]
Variable pymdtools::__email__
Variable Documentation
string pymdtools.__email__ = "florent.tournois@gmail.fr"
Variable pymdtools::__license__
Variable Documentation
string pymdtools.__license__ = "MIT"
Variable pymdtools::__maintainer__
Variable Documentation
string pymdtools.__maintainer__ = "Florent Tournois"
Variable pymdtools::__module_name__
Variable Documentation
string pymdtools.__module_name__ = "pymdtools"
Variable pymdtools::__status__
Variable Documentation
string pymdtools.__status__ = "Production"
Variable pymdtools::__version__
Variable Documentation
string pymdtools.__version__ = '.'.join(str(c) for c in __version_info__)
Variable pymdtools::common::_TEXT_BOMS
Variable Documentation
tuple pymdtools.common._TEXT_BOMS= ( codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE, codecs.BOM_UTF32_BE, codecs.BOM_UTF32_LE, codecs.BOM_UTF8,)
Variable pymdtools::instruction::__begin_include_re__
Variable Documentation
pymdtools.instruction.__begin_include_re__ = \
Variable pymdtools::instruction::__begin_ref_re__
Variable Documentation
pymdtools.instruction.__begin_ref_re__ = \
Variable pymdtools::instruction::__begin_var_re__
Variable Documentation
pymdtools.instruction.__begin_var_re__ = \
Variable pymdtools::instruction::__comment_re__
Variable Documentation
pymdtools.instruction.__comment_re__ = \
Variable pymdtools::instruction::__end_include_re__
Variable Documentation
pymdtools.instruction.__end_include_re__ = \
Variable pymdtools::instruction::__end_ref_re__
Variable Documentation
pymdtools.instruction.__end_ref_re__ = \
Variable pymdtools::instruction::__end_var_re__
Variable Documentation
pymdtools.instruction.__end_var_re__ = \
Variable pymdtools::instruction::__include_file_re__
Variable Documentation
pymdtools.instruction.__include_file_re__ = \
Variable pymdtools::instruction::__var_re__
Variable Documentation
pymdtools.instruction.__var_re__ = \
Variable pymdtools::markdownify::ATX
Variable Documentation
string pymdtools.markdownify.ATX = 'atx'
Variable pymdtools::markdownify::ATX_CLOSED
Variable Documentation
string pymdtools.markdownify.ATX_CLOSED = 'atx_closed'
Variable pymdtools::markdownify::convert_heading_re
Variable Documentation
pymdtools.markdownify.convert_heading_re = re.compile(r'convert_h(d+)')
Variable pymdtools::markdownify::FRAGMENT_ID
Variable Documentation
string pymdtools.markdownify.FRAGMENT_ID = '__MARKDOWNIFY_WRAPPER__'
Variable pymdtools::markdownify::line_beginning_re
Variable Documentation
pymdtools.markdownify.line_beginning_re = re.compile(r'^', re.MULTILINE)
Variable pymdtools::markdownify::SETEXT
Variable Documentation
string pymdtools.markdownify.SETEXT = UNDERLINED
Variable pymdtools::markdownify::UNDERLINED
Variable Documentation
string pymdtools.markdownify.UNDERLINED = 'underlined'
Variable pymdtools::markdownify::unicode
Variable Documentation
pymdtools.markdownify.unicode = six.text_type
Variable pymdtools::markdownify::whitespace_re
Variable Documentation
pymdtools.markdownify.whitespace_re = re.compile(r'[rnst ]+')
Variable pymdtools::markdownify::wrapped
Variable Documentation
string pymdtools.markdownify.wrapped = '<div id="%s">%%s</div>' % FRAGMENT_ID
Variable pymdtools::mistunege::__all__
Variable Documentation
list pymdtools.mistunege.__all__= [ 'BlockGrammar', 'BlockLexer', 'InlineGrammar', 'InlineLexer', 'Renderer', 'Markdown', 'markdown', 'escape',]
Variable pymdtools::mistunege::__author__
Variable Documentation
string pymdtools.mistunege.__author__ = 'Hsiaoming Yang <me@lepture.com>'
Variable pymdtools::mistunege::__version__
Variable Documentation
string pymdtools.mistunege.__version__ = '0.7.3'
Variable pymdtools::mistunege::_block_code_leading_pattern
Variable Documentation
pymdtools.mistunege._block_code_leading_pattern = re.compile(r'^ {4}', re.M)
Variable pymdtools::mistunege::_block_quote_leading_pattern
Variable Documentation
pymdtools.mistunege._block_quote_leading_pattern = re.compile(r'^ *> ?', flags=re.M)
Variable pymdtools::mistunege::_block_tag
Variable Documentation
string pymdtools.mistunege._block_tag = r'(?!(?:%s)b)w+%s' % ('|'.join(_inline_tags), _valid_end)
Variable pymdtools::mistunege::_escape_pattern
Variable Documentation
pymdtools.mistunege._escape_pattern = re.compile(r'&(?!#?w+;)')
Variable pymdtools::mistunege::_inline_tags
Variable Documentation
list pymdtools.mistunege._inline_tags= [ 'a', 'em', 'strong', 'small', 's', 'cite', 'q', 'dfn', 'abbr', 'data', 'time', 'code', 'var', 'samp', 'kbd', 'sub', 'sup', 'i', 'b', 'u', 'mark', 'ruby', 'rt', 'rp', 'bdi', 'bdo', 'span', 'br', 'wbr', 'ins', 'del', 'img', 'font',]
Variable pymdtools::mistunege::_key_pattern
Variable Documentation
pymdtools.mistunege._key_pattern = re.compile(r's+')
Variable pymdtools::mistunege::_newline_pattern
Variable Documentation
pymdtools.mistunege._newline_pattern = re.compile(r'rn|r')
Variable pymdtools::mistunege::_nonalpha_pattern
Variable Documentation
pymdtools.mistunege._nonalpha_pattern = re.compile(r'W')
Variable pymdtools::mistunege::_pre_tags
Variable Documentation
list pymdtools.mistunege._pre_tags = ['pre', 'script', 'style']
Variable pymdtools::mistunege::_scheme_blacklist
Variable Documentation
tuple pymdtools.mistunege._scheme_blacklist = ('javascript:', 'vbscript:')
Variable pymdtools::mistunege::_valid_attr
Variable Documentation
string pymdtools.mistunege._valid_attr = r'''s*[a-zA-Z-](?:=(?:"[^"]*"|'[^']*'|d+))*'''
Variable pymdtools::mistunege::_valid_end
Variable Documentation
string pymdtools.mistunege._valid_end = r'(?!:/|[^ws@]*@)b'
Variable pymdtools::translate::__all__
Variable Documentation
list pymdtools.translate.__all__ = ["N_", "translate", "translate_txt", "translate_md"]
Variable pymdtools::version::__release_date__
Variable Documentation
string pymdtools.version.__release_date__ = '2020-03-25'
Variable pymdtools::version::__version_info__
Variable Documentation
tuple pymdtools.version.__version_info__ = (1, 0, 17)

Full API

Namespaces

Classes and Structs

Functions

Variables

Indices and tables