def get_verto_block_patterns():
"""Get list of compiled regex patterns for verto block tags.
Returns:
(list) list of verto block regexes compiled with re.compile"""
convertor = Verto()
ext = convertor.verto_extension
block_pattern = ext.processor_info['style']['block_pattern']
block_strings = ext.processor_info['style']['strings']['block']
patterns = []
for block_string in block_strings:
c = re.compile(block_pattern.format(**{'block': block_string}))
patterns.append(c)
return patterns
def setup_md_to_html_converter(self):
"""Create Markdown converter.
The converter is created with custom processors, html templates,
and extensions.
"""
templates = self.load_template_files()
extensions = [
"markdown.extensions.fenced_code",
"markdown.extensions.codehilite", "markdown.extensions.sane_lists",
"markdown.extensions.tables",
mdx_math.MathExtension()
]
self.converter = Verto(html_templates=templates, extensions=extensions)
def setup_md_to_html_converter(self):
"""Create Markdown converter.
The converter is created with custom processors, html templates,
and extensions.
"""
templates = self.load_template_files()
extensions = [
"markdown.extensions.fenced_code",
"markdown.extensions.codehilite", "markdown.extensions.sane_lists",
"markdown.extensions.tables",
mdx_math.MathExtension()
]
settings = {
"add_default_interactive_thumbnails_to_required_files": False,
}
self.converter = Verto(html_templates=templates,
extensions=extensions,
custom_settings=settings)
def test_compile_files_custom(self):
'''Tests that some example files are converted with custom
html-templates.
'''
custom_templates = {
'image': '<img />',
'boxed-text': '<div class="box"></div>'
}
verto = Verto(html_templates=custom_templates)
for chapter in ['algorithms.md', 'introduction.md']:
text = pkg_resources.resource_string(
'verto', self.assets_template.format(chapter)).decode('utf-8')
result = verto.convert(text)
self.assertIsNot(result, None)
self.assertIsNot(result.title, None)
self.assertIsNot(result.html_string, None)
self.assertTrue(len(result.html_string) > 0)
"""Module for the custom Django load_style_errors command."""
import importlib
from django.core import management
from verto import Verto
from verto.errors.Error import Error as VertoError
from style.utils import get_language_slugs
from style.models import Error
from utils.errors.VertoConversionError import VertoConversionError
BASE_DATA_MODULE_PATH = 'style.style_checkers.{}_data'
MARKDOWN_CONVERTER = Verto(extensions=[
"markdown.extensions.fenced_code",
], )
class Command(management.base.BaseCommand):
"""Required command class for the custom Django load_style_errors command."""
help = "Load progress outcomes to database."
def convert_markdown(self, module_path, code, field, markdown):
"""Render Markdown string to HTML.
Args:
module_path (str): Path to Python 3 module.
code (str): Code of style error that text belongs too.
field (str): Field of style error that text belongs too.
markdown (str): Markdown text to convert.
Returns:
def convert_md_file(self,
md_file_path,
config_file_path,
heading_required=True,
remove_title=True):
"""Return the Verto object for a given Markdown file.
Args:
md_file_path: Location of Markdown file to convert (str).
config_file_path: Path to related the config file (str).
heading_required: Boolean if the file requires a heading (bool).
remove_title: Boolean if the file's first heading should be removed (bool).
Returns:
VertoResult object
Raises:
CouldNotFindMarkdownFileError: when a given Markdown file cannot be found.
NoHeadingFoundInMarkdownFileError: when no heading can be found in a given
Markdown file.
EmptyMarkdownFileError: when no content can be found in a given Markdown
file.
VertoConversionError: when a verto StyleError is thrown.
"""
try:
# Check file exists
content = open(md_file_path, encoding="UTF-8").read()
except FileNotFoundError:
raise CouldNotFindMarkdownFileError(md_file_path, config_file_path)
""" Below is a hack to make the image-inline tag not require alt text to be
given when the language is not in English.
TODO: Remove this hack once translations are complete.
"""
directories = md_file_path.split('/')
if 'en' not in directories:
custom_argument_rules = {
"image-container": {
"alt": False
},
"image-inline": {
"alt": False
},
"image-tag": {
"alt": False
}
}
else:
custom_argument_rules = {
"image-container": {
"alt": True
},
"image-inline": {
"alt": True
},
"image-tag": {
"alt": True
}
}
custom_processors = self.converter.processor_defaults()
if remove_title:
custom_processors.add("remove-title")
templates = self.load_template_files()
extensions = [
"markdown.extensions.fenced_code",
"markdown.extensions.codehilite", "markdown.extensions.sane_lists",
"markdown.extensions.tables",
mdx_math.MathExtension()
]
self.converter = Verto(html_templates=templates,
extensions=extensions,
custom_argument_rules=custom_argument_rules,
processors=custom_processors)
""" End of hack. """
result = None
try:
result = self.converter.convert(content)
except VertoError as e:
raise VertoConversionError(md_file_path, e) from e
if heading_required:
if result.title is None:
raise NoHeadingFoundInMarkdownFileError(md_file_path)
if len(result.html_string) == 0:
raise EmptyMarkdownFileError(md_file_path)
if not self.lite_loader:
check_converter_required_files(result.required_files, md_file_path)
check_converter_glossary_links(result.required_glossary_terms,
md_file_path)
return result
def setUp(self):
'''Run before any testcases.
'''
self.verto = Verto()
