def typogrify_wrapper(text):
"""Ensures ignore_tags feature is backward compatible"""
try:
return typogrify(text,
self.settings['TYPOGRIFY_IGNORE_TAGS'])
except TypeError:
return typogrify(text)
def read_file(filename, fmt=None, settings=None):
"""Return a reader object using the given format."""
if not fmt:
fmt = filename.split('.')[-1]
if fmt not in _EXTENSIONS:
raise TypeError('Pelican does not know how to parse %s' % filename)
reader = _EXTENSIONS[fmt](settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
if not reader.enabled:
raise ValueError("Missing dependencies for %s" % fmt)
content, metadata = reader.read(filename)
# eventually filter the content with typogrify if asked so
if settings and settings['TYPOGRIFY']:
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
return content, metadata
def read_file(filename, fmt=None, settings=None):
"""Return a reader object using the given format."""
if not fmt:
fmt = filename.split('.')[-1]
if fmt not in _EXTENSIONS:
raise TypeError('Pelican does not know how to parse %s' % filename)
reader = _EXTENSIONS[fmt](settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
if not reader.enabled:
raise ValueError("Missing dependencies for %s" % fmt)
content, metadata = reader.read(filename)
# eventually filter the content with typogrify if asked so
if settings and settings['TYPOGRIFY']:
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
return content, metadata
def read_file(path, fmt=None, settings=None):
"""Return a reader object using the given format."""
base, ext = os.path.splitext(os.path.basename(path))
if not fmt:
fmt = ext[1:]
if fmt not in EXTENSIONS:
raise TypeError('Pelican does not know how to parse {}'.format(path))
if settings is None:
settings = {}
reader = EXTENSIONS[fmt](settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
if not reader.enabled:
raise ValueError("Missing dependencies for %s" % fmt)
metadata = parse_path_metadata(
path=path, settings=settings, process=reader.process_metadata)
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
# eventually filter the content with typogrify if asked so
if content and settings and settings.get('TYPOGRIFY'):
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
return content, metadata
def read_file(path, fmt=None, settings=None):
"""Return a reader object using the given format."""
base, ext = os.path.splitext(os.path.basename(path))
if not fmt:
fmt = ext[1:]
if fmt not in EXTENSIONS:
raise TypeError('Pelican does not know how to parse {}'.format(path))
reader = EXTENSIONS[fmt](settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
if not reader.enabled:
raise ValueError("Missing dependencies for %s" % fmt)
metadata = parse_path_metadata(path=path,
settings=settings,
process=reader.process_metadata)
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
# eventually filter the content with typogrify if asked so
if content and settings and settings.get('TYPOGRIFY'):
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
return content, metadata
def typogrify_wrapper(text):
"""Ensures ignore_tags feature is backward compatible"""
try:
return typogrify(
text,
self.settings['TYPOGRIFY_IGNORE_TAGS'])
except TypeError:
return typogrify(text)
def _postprocess(self):
if self.rc.get('typogrify', False):
if self.output:
self.output = typogrify(self.output)
if 'title' in self.meta:
self.meta['title'] = typogrify(self.meta['title'])
if 'tags' in self.meta:
self.meta['tags'] = [t.strip() for t in self.meta['tags'].split(',')]
def read_file(self, base_path, path, content_class=Page, fmt=None,
context=None, preread_signal=None, preread_sender=None,
context_signal=None, context_sender=None):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
logger.debug('read file {} -> {}'.format(
source_path, content_class.__name__))
if not fmt:
_, ext = os.path.splitext(os.path.basename(path))
fmt = ext[1:]
if fmt not in self.readers:
raise TypeError(
'Pelican does not know how to parse {}'.format(path))
if preread_signal:
logger.debug('signal {}.send({})'.format(
preread_signal, preread_sender))
preread_signal.send(preread_sender)
reader = self.readers[fmt]
metadata = default_metadata(
settings=self.settings, process=reader.process_metadata)
metadata.update(path_metadata(
full_path=path, source_path=source_path,
settings=self.settings))
metadata.update(parse_path_metadata(
source_path=source_path, settings=self.settings,
process=reader.process_metadata))
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
if content:
# find images with empty alt
find_empty_alt(content, path)
# eventually filter the content with typogrify if asked so
if self.settings['TYPOGRIFY']:
from typogrify.filters import typogrify
if content:
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
if 'summary' in metadata:
metadata['summary'] = typogrify(metadata['summary'])
if context_signal:
logger.debug('signal {}.send({}, <metadata>)'.format(
context_signal, context_sender))
context_signal.send(context_sender, metadata=metadata)
return content_class(content=content, metadata=metadata,
settings=self.settings, source_path=path,
context=context)
def read_file(
base_path,
path,
content_class=Page,
fmt=None,
settings=None,
context=None,
preread_signal=None,
preread_sender=None,
context_signal=None,
context_sender=None,
):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
base, ext = os.path.splitext(os.path.basename(path))
logger.debug("read file {} -> {}".format(source_path, content_class.__name__))
if not fmt:
fmt = ext[1:]
if fmt not in EXTENSIONS:
raise TypeError("Pelican does not know how to parse {}".format(path))
if preread_signal:
logger.debug("signal {}.send({})".format(preread_signal, preread_sender))
preread_signal.send(preread_sender)
if settings is None:
settings = {}
reader_class = EXTENSIONS[fmt]
if not reader_class.enabled:
raise ValueError("Missing dependencies for {}".format(fmt))
reader = reader_class(settings)
settings_key = "%s_EXTENSIONS" % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
metadata = default_metadata(settings=settings, process=reader.process_metadata)
metadata.update(path_metadata(full_path=path, source_path=source_path, settings=settings))
metadata.update(parse_path_metadata(source_path=source_path, settings=settings, process=reader.process_metadata))
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
# eventually filter the content with typogrify if asked so
if content and settings and settings["TYPOGRIFY"]:
from typogrify.filters import typogrify
content = typogrify(content)
metadata["title"] = typogrify(metadata["title"])
if context_signal:
logger.debug("signal {}.send({}, <metadata>)".format(context_signal, context_sender))
context_signal.send(context_sender, metadata=metadata)
return content_class(content=content, metadata=metadata, settings=settings, source_path=path, context=context)
def typogrify(self):
"""filter the content with typogrify"""
if self._settings.get('TYPOGRIFY', False):
from typogrify.filters import typogrify
if self._content:
self._content = typogrify(self._content)
self._metadata['title'] = typogrify(self._metadata['title'])
if 'summary' in self._metadata:
self._metadata['summary'] = typogrify(self._metadata['summary'])
def read_file(self, base_path, path, content_class=Page, fmt=None,
context=None, preread_signal=None, preread_sender=None,
context_signal=None, context_sender=None):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
logger.debug('read file {} -> {}'.format(
source_path, content_class.__name__))
if not fmt:
_, ext = os.path.splitext(os.path.basename(path))
fmt = ext[1:]
if fmt not in self.readers:
raise TypeError(
'Pelican does not know how to parse {}'.format(path))
if preread_signal:
logger.debug('signal {}.send({})'.format(
preread_signal, preread_sender))
preread_signal.send(preread_sender)
reader = self.readers[fmt]
metadata = default_metadata(
settings=self.settings, process=reader.process_metadata)
metadata.update(path_metadata(
full_path=path, source_path=source_path,
settings=self.settings))
metadata.update(parse_path_metadata(
source_path=source_path, settings=self.settings,
process=reader.process_metadata))
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
if content:
# find images with empty alt
find_empty_alt(content, path)
# eventually filter the content with typogrify if asked so
if content and self.settings['TYPOGRIFY']:
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
if context_signal:
logger.debug('signal {}.send({}, <metadata>)'.format(
context_signal, context_sender))
context_signal.send(context_sender, metadata=metadata)
return content_class(content=content, metadata=metadata,
settings=self.settings, source_path=path,
context=context)
def process_content(instance):
"""Processes content, with logic to ensure that typogrify does not clash
with math.
In addition, mathjax script is inserted at the end of the content thereby
making it independent of the template
"""
if not instance._content:
return
ignore_within = ignore_content(instance._content)
if _WRAP_LATEX:
instance._content, math = wrap_math(instance._content, ignore_within)
else:
math = True if _MATH_REGEX.search(instance._content) else False
# The user initially set typogrify to be True, but since it would clash
# with math, we set it to False. This means that the default reader will
# not call typogrify, so it is called here, where we are able to control
# logic for it ignore math if necessary
if _TYPOGRIFY:
# Tell typogrify to ignore the tags that math has been wrapped in
# also, typogrify must always ignore mml (math) tags
ignore_tags = [_WRAP_LATEX, 'math'] if _WRAP_LATEX else ['math']
# Exact copy of the logic as found in the default reader
from typogrify.filters import typogrify
instance._content = typogrify(instance._content, ignore_tags)
instance.metadata['title'] = typogrify(instance.metadata['title'],
ignore_tags)
if math:
if _MATHJAX_SETTINGS['auto_insert']:
# Mathjax script added to content automatically. Now it
# does not need to be explicitly added to the template
instance._content += _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
else:
# Place the burden on ensuring mathjax script is available to
# browser on the template designer (see README for more details)
instance.mathjax = True
# The summary needs special care because math math cannot just be cut
# off
summary = process_summary(instance, ignore_within)
if summary != None:
instance._summary = summary
def markup(text):
"""
Use this filter to convert Markdown syntax used in the text to HTML on the template.
Example: {{ var| markup }}
"""
return typogrify(markdown.markdown(text, lazy_ol=False, output_format='html5', extensions=['abbr', 'codehilite', 'fenced_code', 'sane_lists', 'smart_strong']))
def process_content(instance):
"""Processes content, with logic to ensure that typogrify does not clash
with math.
In addition, mathjax script is inserted at the end of the content thereby
making it independent of the template
"""
if not instance._content:
return
ignore_within = ignore_content(instance._content)
if _WRAP_LATEX:
instance._content, math = wrap_math(instance._content, ignore_within)
else:
math = True if _MATH_REGEX.search(instance._content) else False
# The user initially set typogrify to be True, but since it would clash
# with math, we set it to False. This means that the default reader will
# not call typogrify, so it is called here, where we are able to control
# logic for it ignore math if necessary
if _TYPOGRIFY:
# Tell typogrify to ignore the tags that math has been wrapped in
# also, typogrify must always ignore mml (math) tags
ignore_tags = [_WRAP_LATEX,'math'] if _WRAP_LATEX else ['math']
# Exact copy of the logic as found in the default reader
from typogrify.filters import typogrify
instance._content = typogrify(instance._content, ignore_tags)
instance.metadata['title'] = typogrify(instance.metadata['title'], ignore_tags)
if math:
if _MATHJAX_SETTINGS['auto_insert']:
# Mathjax script added to content automatically. Now it
# does not need to be explicitly added to the template
instance._content += _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
else:
# Place the burden on ensuring mathjax script is available to
# browser on the template designer (see README for more details)
instance.mathjax = True
# The summary needs special care because math math cannot just be cut
# off
summary = process_summary(instance, ignore_within)
if summary != None:
instance._summary = summary
def markup(text):
"""
Mark up plain text into fancy HTML.
"""
return typogrify(
markdown(text,
lazy_ol=False,
output_format='html5',
extensions=['abbr', 'codehilite', 'fenced_code', 'sane_lists',
'smart_strong']))
def process_content(instance):
"""Processes content, with logic to ensure that typogrify does not clash
with latex.
In addition, mathjax script is inserted at the end of the content thereby
making it independent of the template
"""
if not instance._content:
return
ignore_within = ignore_content(instance._content)
if _WRAP_TAG:
instance._content, latex = wrap_latex(instance._content, ignore_within)
else:
latex = True if _LATEX_REGEX.search(instance._content) else False
# The user initially set typogrify to be True, but since it would clash
# with latex, we set it to False. This means that the default reader will
# not call typogrify, so it is called here, where we are able to control
# logic for it ignore latex if necessary
if _TYPOGRIFY:
# Tell typogrify to ignore the tags that latex has been wrapped in
# also, typogrify must always ignore mml (math) tags
ignore_tags = [_WRAP_TAG,'math'] if _WRAP_TAG else ['math']
# Exact copy of the logic as found in the default reader
from typogrify.filters import typogrify
instance._content = typogrify(instance._content, ignore_tags)
instance.metadata['title'] = typogrify(instance.metadata['title'], ignore_tags)
if latex:
# Mathjax script added to the end of article. Now it does not need to
# be explicitly added to the template
instance._content += _MATHJAX_SCRIPT.format(**_MATHJAX_SETTINGS)
# The summary needs special care because latex math cannot just be cut
# off
summary = process_summary(instance, ignore_within)
if summary != None:
instance._summary = summary
def present_story_so_far(self):
if not self.state.messages:
self.state = self.state.render_situation()
story_text = u'\n\n'.join(m for m in self.state.messages
if m is not None and m.strip())
logger.debug("#### The Story:\n%s", story_text)
md_extensions = self.plot.config['markdown']['extensions']
story_text = markdown.markdown(story_text, extensions=md_extensions)
story = typogrify(story_text)
return story
def read_file(path, fmt=None, settings=None):
"""Return a reader object using the given format."""
base, ext = os.path.splitext(os.path.basename(path))
if not fmt:
fmt = ext[1:]
if fmt not in _EXTENSIONS:
raise TypeError('Pelican does not know how to parse {}'.format(path))
reader = _EXTENSIONS[fmt](settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
if not reader.enabled:
raise ValueError("Missing dependencies for %s" % fmt)
content, metadata = reader.read(path)
# eventually filter the content with typogrify if asked so
if settings and settings.get('TYPOGRIFY'):
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
file_metadata = settings and settings.get('FILENAME_METADATA')
if file_metadata:
match = re.match(file_metadata, base)
if match:
# .items() for py3k compat.
for k, v in match.groupdict().items():
if k not in metadata:
k = k.lower() # metadata must be lowercase
metadata[k] = reader.process_metadata(k, v)
return content, metadata
def read_file(filename, fmt=None, settings=None):
"""Return a reader object using the given format."""
base, ext = os.path.splitext(os.path.basename(filename))
if not fmt:
fmt = ext[1:]
if fmt not in _EXTENSIONS:
raise TypeError('Pelican does not know how to parse %s' % filename)
reader = _EXTENSIONS[fmt](settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
if not reader.enabled:
raise ValueError("Missing dependencies for %s" % fmt)
content, metadata = reader.read(filename)
# eventually filter the content with typogrify if asked so
if settings and settings.get('TYPOGRIFY'):
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
filename_metadata = settings and settings.get('FILENAME_METADATA')
if filename_metadata:
match = re.match(filename_metadata, base)
if match:
# .items() for py3k compat.
for k, v in match.groupdict().items():
if k not in metadata:
k = k.lower() # metadata must be lowercase
metadata[k] = reader.process_metadata(k, v)
return content, metadata
def render_files(settings, template, context={}):
env = Environment(loader=FileSystemLoader(os.path.dirname(__file__)))
if 'context' in settings:
settings['context'].update(context)
else:
settings['context'] = context
full_context = {k.upper(): v for k, v in settings['context'].items()}
try:
used_template = template if template else settings['template']
except KeyError:
print('Some error shit') # TODO: Logging
sys.exit()
html_output = env.get_template(settings['template']).render(**full_context)
text_output = fromstring(html_output).text_content()
typo_output = typogrify(html_output)
if settings.get('html_output'):
with open(settings['html_output'], 'w') as html:
html.write(typo_output)
if settings.get('text_output'):
with open(settings['text_output'], 'w') as text:
text.write(text_output)
else:
print(text_output)
def render_files(settings, template, context={}):
env = Environment(loader=FileSystemLoader(os.path.dirname(__file__)))
if 'context' in settings:
settings['context'].update(context)
else:
settings['context'] = context
full_context = {k.upper(): v for k, v in settings['context'].items()}
try:
used_template = template if template else settings['template']
except KeyError:
print('Some error shit') # TODO: Logging
sys.exit()
html_output = env.get_template(settings['template']).render(**full_context)
text_output = fromstring(html_output).text_content()
typo_output = typogrify(html_output)
if settings.get('html_output'):
with open(settings['html_output'], 'w') as html:
html.write(typo_output)
if settings.get('text_output'):
with open(settings['text_output'], 'w') as text:
text.write(text_output)
else:
print(text_output)
def render_files(settings, template, context={}):
try:
used_template = template if template else settings['template']
except KeyError:
LOGGER.error('No template defined')
sys.exit()
env = Environment(loader=FileSystemLoader(os.getcwd()))
if 'context' in settings:
settings['context'].update(context)
else:
settings['context'] = context
full_context = {k.upper(): v for k, v in settings['context'].items()}
html_output = env.get_template(settings['template']).render(**full_context)
text_output = fromstring(html_output).text_content()
typo_output = typogrify(html_output)
output_files = settings['output']
if output_files.get('html'):
with open(output_files.get('html'), 'w') as html:
html.write(typo_output)
if output_files.get('text'):
with open(output_files.get('text'), 'w') as text:
text.write(text_output)
else:
print(text_output)
def render_files(settings, template, context={}):
try:
used_template = template if template else settings['template']
except KeyError:
LOGGER.error('No template defined')
sys.exit()
env = Environment(loader=FileSystemLoader(os.getcwd()))
if 'context' in settings:
settings['context'].update(context)
else:
settings['context'] = context
full_context = {k.upper(): v for k, v in settings['context'].items()}
html_output = env.get_template(settings['template']).render(**full_context)
text_output = fromstring(html_output).text_content()
typo_output = typogrify(html_output)
output_files = settings['output']
if output_files.get('html'):
with open(output_files.get('html'), 'w') as html:
html.write(typo_output)
if output_files.get('text'):
with open(output_files.get('text'), 'w') as text:
text.write(text_output)
else:
print(text_output)
def typeset(md):
html = markdown(md, extensions=MARKDOWN_EXTRAS)
typogrified_html = typogrify(html)
return typogrified_html
def handle_endtag(self, tag):
if self.is_applicable:
new_content = typogrify(self.content)
if self.content != new_content:
self.targets.append((self.content, new_content))
self.is_applicable = True
def typeset(md):
html = markdown(md, extensions=MARKDOWN_EXTRAS)
typogrified_html = typogrify(html)
return typogrified_html
def _typogrify(caller):
return typogrify(caller().unescape()).strip()
def convert_to_html(content):
return typogrify(markdown.markdown(content, extensions=['extra', 'codehilite']))
def rendruj(m):
return Markup(typogrify(markdown(m)))
def read_file(base_path,
path,
content_class=Page,
fmt=None,
settings=None,
context=None,
preread_signal=None,
preread_sender=None,
context_signal=None,
context_sender=None):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
base, ext = os.path.splitext(os.path.basename(path))
logger.debug('read file {} -> {}'.format(source_path,
content_class.__name__))
if not fmt:
fmt = ext[1:]
if fmt not in EXTENSIONS:
raise TypeError('Pelican does not know how to parse {}'.format(path))
if preread_signal:
logger.debug('signal {}.send({})'.format(preread_signal,
preread_sender))
preread_signal.send(preread_sender)
if settings is None:
settings = {}
reader_class = EXTENSIONS[fmt]
if not reader_class.enabled:
raise ValueError('Missing dependencies for {}'.format(fmt))
reader = reader_class(settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
metadata = default_metadata(settings=settings,
process=reader.process_metadata)
metadata.update(
path_metadata(full_path=path,
source_path=source_path,
settings=settings))
metadata.update(
parse_path_metadata(source_path=source_path,
settings=settings,
process=reader.process_metadata))
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
# create warnings for all images with empty alt (up to a certain number)
# as they are really likely to be accessibility flaws
if content:
# find images with empty alt
imgs = re.compile(
r"""
(?:
# src before alt
<img
[^\>]*
src=(['"])(.*)\1
[^\>]*
alt=(['"])\3
)|(?:
# alt before src
<img
[^\>]*
alt=(['"])\4
[^\>]*
src=(['"])(.*)\5
)
""", re.X)
matches = re.findall(imgs, content)
# find a correct threshold
nb_warnings = 10
if len(matches) == nb_warnings + 1:
nb_warnings += 1 # avoid bad looking case
# print one warning per image with empty alt until threshold
for match in matches[:nb_warnings]:
logger.warning('Empty alt attribute for image {} in {}'.format(
os.path.basename(match[1] + match[5]), path))
# print one warning for the other images with empty alt
if len(matches) > nb_warnings:
logger.warning('{} other images with empty alt attributes'.format(
len(matches) - nb_warnings))
# eventually filter the content with typogrify if asked so
if content and settings and settings['TYPOGRIFY']:
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
if context_signal:
logger.debug('signal {}.send({}, <metadata>)'.format(
context_signal, context_sender))
context_signal.send(context_sender, metadata=metadata)
return content_class(content=content,
metadata=metadata,
settings=settings,
source_path=path,
context=context)
def read_file(base_path, path, content_class=Page, fmt=None,
settings=None, context=None,
preread_signal=None, preread_sender=None,
context_signal=None, context_sender=None):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
base, ext = os.path.splitext(os.path.basename(path))
logger.debug('read file {} -> {}'.format(
source_path, content_class.__name__))
if not fmt:
fmt = ext[1:]
if fmt not in EXTENSIONS:
raise TypeError('Pelican does not know how to parse {}'.format(path))
if preread_signal:
logger.debug('signal {}.send({})'.format(
preread_signal, preread_sender))
preread_signal.send(preread_sender)
if settings is None:
settings = {}
reader_class = EXTENSIONS[fmt]
if not reader_class.enabled:
raise ValueError('Missing dependencies for {}'.format(fmt))
reader = reader_class(settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
metadata = default_metadata(
settings=settings, process=reader.process_metadata)
metadata.update(path_metadata(
full_path=path, source_path=source_path, settings=settings))
metadata.update(parse_path_metadata(
source_path=source_path, settings=settings,
process=reader.process_metadata))
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
# create warnings for all images with empty alt (up to a certain number)
# as they are really likely to be accessibility flaws
if content:
# find images with empty alt
imgs = re.compile(r"""
(?:
# src before alt
<img
[^\>]*
src=(['"])(.*)\1
[^\>]*
alt=(['"])\3
)|(?:
# alt before src
<img
[^\>]*
alt=(['"])\4
[^\>]*
src=(['"])(.*)\5
)
""", re.X)
matches = re.findall(imgs, content)
# find a correct threshold
nb_warnings = 10
if len(matches) == nb_warnings + 1:
nb_warnings += 1 # avoid bad looking case
# print one warning per image with empty alt until threshold
for match in matches[:nb_warnings]:
logger.warning('Empty alt attribute for image {} in {}'.format(
os.path.basename(match[1] + match[5]), path))
# print one warning for the other images with empty alt
if len(matches) > nb_warnings:
logger.warning('{} other images with empty alt attributes'.format(
len(matches) - nb_warnings))
# eventually filter the content with typogrify if asked so
if content and settings and settings['TYPOGRIFY']:
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
if context_signal:
logger.debug('signal {}.send({}, <metadata>)'.format(
context_signal, context_sender))
context_signal.send(context_sender, metadata=metadata)
return content_class(
content=content,
metadata=metadata,
settings=settings,
source_path=path,
context=context)
def run(content):
return typogrify(content)
def convert_to_html(content):
return typogrify(markdown.markdown(content, extensions=['extra', 'codehilite']))
def markup(text): """ Use this filter to convert Markdown syntax used in the text to HTML on the template. """ return typogrify(markdown.markdown(text, lazy_ol=False, output_format='html5', extensions=['abbr', 'codehilite', 'fenced_code', 'sane_lists', 'smart_strong']))
def typogrify(s):
return jinja2_filters.typogrify(s)
def read_file(self, base_path, path, content_class=Page, fmt=None,
context=None, preread_signal=None, preread_sender=None,
context_signal=None, context_sender=None):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
logger.debug('Read file %s -> %s',
source_path, content_class.__name__)
if not fmt:
_, ext = os.path.splitext(os.path.basename(path))
fmt = ext[1:]
if fmt not in self.readers:
raise TypeError(
'Pelican does not know how to parse %s', path)
if preread_signal:
logger.debug('Signal %s.send(%s)',
preread_signal.name, preread_sender)
preread_signal.send(preread_sender)
reader = self.readers[fmt]
metadata = default_metadata(
settings=self.settings, process=reader.process_metadata)
metadata.update(path_metadata(
full_path=path, source_path=source_path,
settings=self.settings))
metadata.update(parse_path_metadata(
source_path=source_path, settings=self.settings,
process=reader.process_metadata))
reader_name = reader.__class__.__name__
metadata['reader'] = reader_name.replace('Reader', '').lower()
content, reader_metadata = self.get_cached_data(path, (None, None))
if content is None:
content, reader_metadata = reader.read(path)
self.cache_data(path, (content, reader_metadata))
metadata.update(reader_metadata)
if content:
# find images with empty alt
find_empty_alt(content, path)
# eventually filter the content with typogrify if asked so
if self.settings['TYPOGRIFY']:
from typogrify.filters import typogrify
if content:
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
if 'summary' in metadata:
metadata['summary'] = typogrify(metadata['summary'])
if context_signal:
logger.debug('Signal %s.send(%s, <metadata>)',
context_signal.name, context_sender)
context_signal.send(context_sender, metadata=metadata)
return content_class(content=content, metadata=metadata,
settings=self.settings, source_path=path,
context=context)
def process_text(self, input_text):
#t = make_safe(typogrify)
#return t(input_text)
return typogrify(input_text)
def typogrify(s):
return jinja2_filters.typogrify(s)
def read_file(base_path,
path,
content_class=Page,
fmt=None,
settings=None,
context=None,
preread_signal=None,
preread_sender=None,
context_signal=None,
context_sender=None):
"""Return a content object parsed with the given format."""
path = os.path.abspath(os.path.join(base_path, path))
source_path = os.path.relpath(path, base_path)
base, ext = os.path.splitext(os.path.basename(path))
logger.debug('read file {} -> {}'.format(source_path,
content_class.__name__))
if not fmt:
fmt = ext[1:]
if fmt not in EXTENSIONS:
raise TypeError('Pelican does not know how to parse {}'.format(path))
if preread_signal:
logger.debug('signal {}.send({})'.format(preread_signal,
preread_sender))
preread_signal.send(preread_sender)
if settings is None:
settings = {}
reader_class = EXTENSIONS[fmt]
if not reader_class.enabled:
raise ValueError('Missing dependencies for {}'.format(fmt))
reader = reader_class(settings)
settings_key = '%s_EXTENSIONS' % fmt.upper()
if settings and settings_key in settings:
reader.extensions = settings[settings_key]
metadata = default_metadata(settings=settings,
process=reader.process_metadata)
metadata.update(
path_metadata(full_path=path,
source_path=source_path,
settings=settings))
metadata.update(
parse_path_metadata(source_path=source_path,
settings=settings,
process=reader.process_metadata))
content, reader_metadata = reader.read(path)
metadata.update(reader_metadata)
# eventually filter the content with typogrify if asked so
if content and settings and settings['TYPOGRIFY']:
from typogrify.filters import typogrify
content = typogrify(content)
metadata['title'] = typogrify(metadata['title'])
if context_signal:
logger.debug('signal {}.send({}, <metadata>)'.format(
context_signal, context_sender))
context_signal.send(context_sender, metadata=metadata)
return content_class(content=content,
metadata=metadata,
settings=settings,
source_path=path,
context=context)
