Small latex mods: Escapes, Headings, Equations

* remove console escapes
* use different heading levels
* allow explicit definition of latex environments

nbconvert/exporters/exporter.py

@@ -1,348 +1,349 b''
 """This module defines Exporter, a highly configurable converter
 that uses Jinja2 to export notebook files into different formats.
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import io
 import os
 import inspect
 from copy import deepcopy
 
 # IPython imports
 from IPython.config.configurable import Configurable
 from IPython.config import Config
 from IPython.nbformat import current as nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Bool
 from IPython.utils.text import indent
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader
 from markdown import markdown
 
 # local import
 import nbconvert.filters.strings
 import nbconvert.filters.markdown
 import nbconvert.filters.latex
 import nbconvert.filters.datatypefilter
 import nbconvert.filters.highlight
 import nbconvert.filters.ansi
 
 import nbconvert.transformers.extractfigure
 import nbconvert.transformers.coalescestreams
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 default_filters = {
         'indent': indent,
         'markdown': markdown,
         'ansi2html': nbconvert.filters.ansi.ansi2html,
         'filter_data_type': nbconvert.filters.datatypefilter.DataTypeFilter,
         'get_lines': nbconvert.filters.strings.get_lines,
         'highlight': nbconvert.filters.highlight.highlight,
         'highlight2html': nbconvert.filters.highlight.highlight,
         'highlight2latex': nbconvert.filters.highlight.highlight2latex,
         'markdown2latex': nbconvert.filters.markdown.markdown2latex,
         'markdown2rst': nbconvert.filters.markdown.markdown2rst,
         'pycomment': nbconvert.filters.strings.python_comment,
         'rm_ansi': nbconvert.filters.ansi.remove_ansi,
         'rm_dollars': nbconvert.filters.strings.strip_dollars,
         'rm_fake': nbconvert.filters.strings.rm_fake,
+        'rm_consoleesc': nbconvert.filters.strings.rm_consoleesc,
         'rm_math_space': nbconvert.filters.latex.rm_math_space,
         'wrap': nbconvert.filters.strings.wrap
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class Exporter(Configurable):
     """
     Exports notebooks into other file formats.  Uses Jinja 2 templating engine
     to output new formats.  Inherit from this class if you are creating a new
     template type along with new filters/transformers.  If the filters/
     transformers provided by default suffice, there is no need to inherit from
     this class.  Instead, override the template_file and file_extension
     traits via a config file.
     
     {filters}
     """
     
     # finish the docstring
     __doc__ = __doc__.format(filters = '- '+'\n    - '.join(default_filters.keys()))
 
 
     template_file = Unicode(
             '', config=True,
             help="Name of the template file to use")
 
     file_extension = Unicode(
         'txt', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     template_path = Unicode(
         "/../templates/", config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         "/../templates/skeleton/", config=True,
         help="Path where the template skeleton files are located.") 
 
     #Jinja block definitions
     jinja_comment_block_start = Unicode("", config=True)
     jinja_comment_block_end = Unicode("", config=True)
     jinja_variable_block_start = Unicode("", config=True)
     jinja_variable_block_end = Unicode("", config=True)
     jinja_logic_block_start = Unicode("", config=True)
     jinja_logic_block_end = Unicode("", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tpl", config=True)
 
     #Processors that process the input data prior to the export, set in the 
     #constructor for this class.
     transformers = None
 
     _default_config = Config()
 
     
     def __init__(self, transformers=None, filters=None, config=None, **kw):
         """
         Public constructor
     
         Parameters
         ----------
         transformers : list[of transformer]
             Custom transformers to apply to the notebook prior to engaging
             the Jinja template engine.  Any transformers specified here 
             will override existing transformers if a naming conflict
             occurs.
         filters : dict[of filter]
             filters specified here will override existing filters if a naming
             conflict occurs. Filters are availlable in jinja template through
             the name of the corresponding key. Cf class docstring for
             availlable default filters.
         config : config
             User configuration instance.
         """
         
         #Call the base class constructor
         super(Exporter, self).__init__(config=config, **kw)
 
         #Standard environment
         self._init_environment()
 
         #Add transformers
         self._register_transformers()
 
         #Add filters to the Jinja2 environment
         self._register_filters()
 
         #Load user transformers.  Overwrite existing transformers if need be.
         if transformers :
             for transformer in transformers:
                 self.register_transformer(transformer)
                 
         #Load user filters.  Overwrite existing filters if need be.
         if not filters is None:
             for key, user_filter in filters.iteritems():
                 if issubclass(user_filter, MetaHasTraits):
                     self.environment.filters[key] = user_filter(config=config)
                 else:
                     self.environment.filters[key] = user_filter
 
     @property
     def default_config(self):
         if self._default_config:
             return Config(deepcopy(self._default_config))
         else :
             return Config()
     
     
     def from_notebook_node(self, nb, resources=None):
         """
         Convert a notebook from a notebook node instance.
     
         Parameters
         ----------
         nb : Notebook node
         resources : a dict of additional resources that
                 can be accessed read/write by transformers
                 and filters.
         """
         if resources is None:
             resources = {}
         nb, resources = self._preprocess(nb, resources)
         
         #Load the template file.
         self.template = self.environment.get_template(self.template_file+self.template_extension)
         
         return self.template.render(nb=nb, resources=resources), resources
 
 
     def from_filename(self, filename):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
         
         with io.open(filename) as f:
             return self.from_notebook_node(nbformat.read(f, 'json'))
 
 
     def from_file(self, file_stream):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, 'json'))
 
 
     def register_transformer(self, transformer):
         """
         Register a transformer.
         Transformers are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  Transformers are also
         capable of passing additional information to the Jinja
         templating engine.
     
         Parameters
         ----------
         transformer : transformer
         """
         if self.transformers is None:
             self.transformers = []
         
         if inspect.isfunction(transformer):
             self.transformers.append(transformer)
             return transformer
         elif isinstance(transformer, MetaHasTraits):
             transformer_instance = transformer(config=self.config)
             self.transformers.append(transformer_instance)
             return transformer_instance
         else:
             transformer_instance = transformer()
             self.transformers.append(transformer_instance)
             return transformer_instance
 
 
     def register_filter(self, name, filter):
         """
         Register a filter.
         A filter is a function that accepts and acts on one string.  
         The filters are accesible within the Jinja templating engine.
     
         Parameters
         ----------
         name : str
             name to give the filter in the Jinja engine
         filter : filter
         """
         if inspect.isfunction(filter):
             self.environment.filters[name] = filter
         elif isinstance(filter, MetaHasTraits):
             self.environment.filters[name] = filter(config=self.config)
         else:
             self.environment.filters[name] = filter()
         return self.environment.filters[name]
 
     
     def _register_transformers(self):
         """
         Register all of the transformers needed for this exporter.
         """
          
         self.register_transformer(nbconvert.transformers.coalescestreams.coalesce_streams)
         
         #Remember the figure extraction transformer so it can be enabled and
         #disabled easily later.
         self.extract_figure_transformer = self.register_transformer(nbconvert.transformers.extractfigure.ExtractFigureTransformer)
         
         
     def _register_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         for k, v in default_filters.iteritems():
             self.register_filter(k, v)
         
         
     def _init_environment(self):
         """
         Create the Jinja templating environment.
         """
         
         self.environment = Environment(
             loader=FileSystemLoader([
                 os.path.dirname(os.path.realpath(__file__)) + self.template_path,
                 os.path.dirname(os.path.realpath(__file__)) + self.template_skeleton_path,
                 ]),
             extensions=JINJA_EXTENSIONS
             )
         
         #Set special Jinja2 syntax that will not conflict with latex.
         if self.jinja_logic_block_start:
             self.environment.block_start_string = self.jinja_logic_block_start
         if self.jinja_logic_block_end:
             self.environment.block_end_string = self.jinja_logic_block_end
         if self.jinja_variable_block_start:
             self.environment.variable_start_string = self.jinja_variable_block_start
         if self.jinja_variable_block_end:
             self.environment.variable_end_string = self.jinja_variable_block_end
         if self.jinja_comment_block_start:
             self.environment.comment_start_string = self.jinja_comment_block_start
         if self.jinja_comment_block_end:
             self.environment.comment_end_string = self.jinja_comment_block_end
 
 
     def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the 
     
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
             can be accessed read/write by transformers
             and filters.
         """
         
         # Do a deepcopy first, 
         # we are never safe enough with what the transformers could do.
         nbc =  deepcopy(nb)
         resc = deepcopy(resources)
         #Run each transformer on the notebook.  Carry the output along
         #to each transformer
         for transformer in self.transformers:
             nb, resources = transformer(nbc, resc)
         return nb, resources
 

nbconvert/filters/latex.py

@@ -1,108 +1,109 b''
 """Latex filters.
 
 Module of useful filters for processing Latex within Jinja latex templates.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import re
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Latex substitutions for escaping latex.
 LATEX_SUBS = (
+    (re.compile('\033\[[0-9;]+m'),''),  # handle console escapes
     (re.compile(r'\\'), r'\\textbackslash'),
     (re.compile(r'([{}_#%&$])'), r'\\\1'),
     (re.compile(r'~'), r'\~{}'),
     (re.compile(r'\^'), r'\^{}'),
     (re.compile(r'"'), r"''"),
     (re.compile(r'\.\.\.+'), r'\\ldots'),
 )
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 def escape_latex(text):
     """
     Escape characters that may conflict with latex.
     
     Parameters
     ----------
     text : str
         Text containing characters that may conflict with Latex
     """
     return_text = text
     for pattern, replacement in LATEX_SUBS:
         return_text = pattern.sub(replacement, return_text)
     return return_text
     
     
 def rm_math_space(text):
     """
     Remove the space between latex math commands and enclosing $ symbols.
     This filter is important because latex isn't as flexible as the notebook
     front end when it comes to flagging math using ampersand symbols.
     
     Parameters
     ----------
     text : str
         Text to filter.
     """
 
     # First, scan through the markdown looking for $.  If
     # a $ symbol is found, without a preceding \, assume
     # it is the start of a math block.  UNLESS that $ is
     # not followed by another within two math_lines.
     math_regions = []
     math_lines = 0
     within_math = False
     math_start_index = 0
     ptext = ''
     last_character = ""
     skip = False
     for index, char in enumerate(text):
 
         #Make sure the character isn't preceeded by a backslash
         if (char == "$" and last_character != "\\"):
 
             # Close the math region if this is an ending $
             if within_math:
                 within_math = False
                 skip = True
                 ptext = ptext+'$'+text[math_start_index+1:index].strip()+'$'
                 math_regions.append([math_start_index, index+1])
             else:
 
                 # Start a new math region
                 within_math = True
                 math_start_index = index
                 math_lines = 0
 
         # If we are in a math region, count the number of lines parsed.
         # Cancel the math region if we find two line breaks!
         elif char == "\n":
             if within_math:
                 math_lines += 1
                 if math_lines > 1:
                     within_math = False
                     ptext = ptext+text[math_start_index:index]
 
         # Remember the last character so we can easily watch
         # for backslashes
         last_character = char
         if not within_math and not skip:
             ptext = ptext+char
         if skip:
             skip = False
     return ptext

nbconvert/filters/strings.py

@@ -1,104 +1,117 b''
 """String filters.
 
 Contains a collection of useful string manipulation filters for use in Jinja
 templates.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
+import re
 
 # Our own imports
 import textwrap
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 def wrap(text, width=100):
     """ 
     Intelligently wrap text.
     Wrap text without breaking words if possible.
     
     Parameters
     ----------
     text : str
         Text to wrap.
     width : int, optional
         Number of characters to wrap to, default 100.
     """
 
     split_text = text.split('\n')
     wrp = map(lambda x:textwrap.wrap(x,width), split_text)
     wrpd = map('\n'.join, wrp)
     return '\n'.join(wrpd)
 
 
 def strip_dollars(text):
     """
     Remove all dollar symbols from text
     
     Parameters
     ----------
     text : str
         Text to remove dollars from
     """
 
     return text.strip('$')
 
 
+def rm_consoleesc(text):
+    """
+    Remove console escapes from text
+    
+    Parameters
+    ----------
+    text : str
+        Text to remove '/files/' from
+    """
+    r= re.compile("\033\[[0-9;]+m")
+    return r.sub('', text)
+
 def rm_fake(text):
     """
     Remove all occurrences of '/files/' from text
     
     Parameters
     ----------
     text : str
         Text to remove '/files/' from
     """
     return text.replace('/files/', '')
 
 
 def python_comment(text):
     """
     Build a Python comment line from input text.
     
     Parameters
     ----------
     text : str
         Text to comment out.
     """
     
     #Replace line breaks with line breaks and comment symbols.
     #Also add a comment symbol at the beginning to comment out
     #the first line.
     return '# '+'\n# '.join(text.split('\n')) 
 
 
 def get_lines(text, start=None,end=None):
     """
     Split the input text into separate lines and then return the 
     lines that the caller is interested in.
     
     Parameters
     ----------
     text : str
         Text to parse lines from.
     start : int, optional
         First line to grab from.
     end : int, optional
         Last line to grab from.
     """
     
     # Split the input into lines.
     lines = text.split("\n")
     
     # Return the right lines.
     return "\n".join(lines[start:end]) #re-join

nbconvert/templates/latex/base.tplx

@@ -1,235 +1,251 b''
 ((*- extends 'display_priority.tplx' -*))
 
 ((* block in_prompt *))((* endblock in_prompt *))
 
 ((* block output_prompt *))((* endblock output_prompt *))
 
 ((* block codecell *))\begin{codecell}((( super() )))
 \end{codecell}
 ((* endblock *))
 
 ((* block input *))
 \begin{codeinput}
 \begin{lstlisting}
 ((( cell.input )))
 \end{lstlisting}
 \end{codeinput}
 ((* endblock input *))
 
 
 ((= Those Two are for error displaying
 even if the first one seem to do nothing, 
 it introduces a new line
 
 =))
 ((* block pyerr *))
 \begin{traceback}
 \begin{verbatim}((( super() )))
 \end{verbatim}
 \end{traceback}
 ((* endblock pyerr *))
 
 ((* block traceback_line *))
 ((( line |indent| rm_ansi )))((* endblock traceback_line *))
 ((= .... =))
 
 
 ((*- block output_group -*))
 \begin{codeoutput}
 ((( super() )))
 \end{codeoutput}((* endblock *))
 
 ((*- block data_png -*))
 \begin{center}
 \includegraphics[width=0.7\textwidth, height=0.9\textheight, keepaspectratio]{(((output.key_png)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_jpg -*))
 \begin{center}
 \includegraphics[width=0.7\textwidth, height=0.9\textheight, keepaspectratio]{(((output.key_jpeg)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_svg -*))
 \begin{center}
 \includegraphics[width=0.7\textwidth]{(((output.key_svg)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((* block pyout *))
 ((* block data_priority scoped *))((( super() )))((* endblock *))
 ((* endblock pyout *))
 
 ((* block data_text *))
 \begin{verbatim}
 ((( output.text )))
 \end{verbatim}
 ((* endblock *))
 
 ((* block data_latex -*))
-\begin{equation*}
-((( output.latex | rm_dollars)))
-\end{equation*}
+((*- if output.latex.startswith('$'): -*)) \begin{equation*}
+    ((( output.latex | rm_dollars)))
+    \end{equation*}
+((*- else -*)) ((( output.latex ))) ((*- endif *))
 ((* endblock *))
 
 ((* block stream *))
 \begin{verbatim}
-((( output.text)))
+((( output.text | rm_consoleesc)))
 \end{verbatim}
 ((* endblock stream *))
 
 ((* block markdowncell scoped *))((( cell.source | markdown2latex )))
 ((* endblock markdowncell *))
 
-((* block headingcell scoped *))
-\section{((( cell.source | markdown2latex)))}
+((* block headingcell scoped -*))
+    \
+    ((*- if cell.level == 1 -*))
+        ((* block h1 -*))section((* endblock h1 -*))
+    ((*- elif cell.level == 2 -*))
+        ((* block h2 -*))subsection((* endblock h2 -*))
+    ((*- elif cell.level == 3 -*))
+        ((* block h3 -*))subsubsection((* endblock h3 -*))
+    ((*- elif cell.level == 4 -*))
+        ((* block h4 -*))paragraph((* endblock h4 -*))
+    ((*- elif cell.level == 5 -*))
+        ((* block h5 -*))subparagraph((* endblock h5 -*))
+    ((*- elif cell.level == 6 -*))
+        ((* block h6 -*))subparagraph((* endblock h6 -*))
+        ((= 6th level not available in standard latex =))
+
+    ((*- endif -*)){((( cell.source | markdown2latex )))}
 ((* endblock headingcell *))
 
 ((* block rawcell scoped *))
 ((( cell.source | pycomment )))
 ((* endblock rawcell *))
 
 ((* block unknowncell scoped *))
 unknown type  (((cell.type)))
 ((* endblock unknowncell *))
 
 
 
 ((* block body *))
 
 ((* block bodyBegin *))
 \begin{document}
 ((* endblock bodyBegin *))
 
 ((( super() )))
 
 ((* block bodyEnd *))
 \end{document}
 ((* endblock bodyEnd *))
 ((* endblock body *))
 
 ((* block header *))
 %% This file was auto-generated by IPython.
 %% Conversion from the original notebook file:
 %%
 \documentclass[11pt,english]{article}
 
 %% This is the automatic preamble used by IPython.  Note that it does *not*
 %% include a documentclass declaration, that is added at runtime to the overall
 %% document.
 
 \usepackage{amsmath}
 \usepackage{amssymb}
 \usepackage{graphicx}
 \usepackage{ucs}
 \usepackage[utf8x]{inputenc}
 
 % needed for markdown enumerations to work
 \usepackage{enumerate}
 
 % Slightly bigger margins than the latex defaults
 \usepackage{geometry}
 \geometry{verbose,tmargin=3cm,bmargin=3cm,lmargin=2.5cm,rmargin=2.5cm}
 
 % Define a few colors for use in code, links and cell shading
 \usepackage{color}
 \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
 \definecolor{darkorange}{rgb}{.71,0.21,0.01}
 \definecolor{darkgreen}{rgb}{.12,.54,.11}
 \definecolor{myteal}{rgb}{.26, .44, .56}
 \definecolor{gray}{gray}{0.45}
 \definecolor{lightgray}{gray}{.95}
 \definecolor{mediumgray}{gray}{.8}
 \definecolor{inputbackground}{rgb}{.95, .95, .85}
 \definecolor{outputbackground}{rgb}{.95, .95, .95}
 \definecolor{traceback}{rgb}{1, .95, .95}
 
 % Framed environments for code cells (inputs, outputs, errors, ...).  The
 % various uses of \unskip (or not) at the end were fine-tuned by hand, so don't
 % randomly change them unless you're sure of the effect it will have.
 \usepackage{framed}
 
 % remove extraneous vertical space in boxes
 \setlength\fboxsep{0pt}
 
 % codecell is the whole input+output set of blocks that a Code cell can
 % generate.
 
 % TODO: unfortunately, it seems that using a framed codecell environment breaks
 % the ability of the frames inside of it to be broken across pages.  This
 % causes at least the problem of having lots of empty space at the bottom of
 % pages as new frames are moved to the next page, and if a single frame is too
 % long to fit on a page, will completely stop latex from compiling the
 % document.  So unless we figure out a solution to this, we'll have to instead
 % leave the codecell env. as empty.  I'm keeping the original codecell
 % definition here (a thin vertical bar) for reference, in case we find a
 % solution to the page break issue.
 
 %% \newenvironment{codecell}{%
 %%     \def\FrameCommand{\color{mediumgray} \vrule width 1pt \hspace{5pt}}%
 %%    \MakeFramed{\vspace{-0.5em}}}
 %%  {\unskip\endMakeFramed}
 
 % For now, make this a no-op...
 \newenvironment{codecell}{}
 
  \newenvironment{codeinput}{%
    \def\FrameCommand{\colorbox{inputbackground}}%
    \MakeFramed{\advance\hsize-\width \FrameRestore}}
  {\unskip\endMakeFramed}
 
 \newenvironment{codeoutput}{%
    \def\FrameCommand{\colorbox{outputbackground}}%
    \vspace{-1.4em}
    \MakeFramed{\advance\hsize-\width \FrameRestore}}
  {\unskip\medskip\endMakeFramed}
 
 \newenvironment{traceback}{%
    \def\FrameCommand{\colorbox{traceback}}%
    \MakeFramed{\advance\hsize-\width \FrameRestore}}
  {\endMakeFramed}
 
 % Use and configure listings package for nicely formatted code
 \usepackage{listingsutf8}
 \lstset{
   language=python,
   inputencoding=utf8x,
   extendedchars=\true,
   aboveskip=\smallskipamount,
   belowskip=\smallskipamount,
   xleftmargin=2mm,
   breaklines=true,
   basicstyle=\small \ttfamily,
   showstringspaces=false,
   keywordstyle=\color{blue}\bfseries,
   commentstyle=\color{myteal},
   stringstyle=\color{darkgreen},
   identifierstyle=\color{darkorange},
   columns=fullflexible,  % tighter character kerning, like verb
 }
 
 % The hyperref package gives us a pdf with properly built
 % internal navigation ('pdf bookmarks' for the table of contents,
 % internal cross-reference links, web links for URLs, etc.)
 \usepackage{hyperref}
 \hypersetup{
   breaklinks=true,  % so long urls are correctly broken across lines
   colorlinks=true,
   urlcolor=blue,
   linkcolor=darkorange,
   citecolor=darkgreen,
   }
 
 % hardcode size of all verbatim environments to be a bit smaller
 \makeatletter 
 \g@addto@macro\@verbatim\small\topsep=0.5em\partopsep=0pt
 \makeatother 
 
 % Prevent overflowing lines due to urls and other hard-to-break entities.
 \sloppy
 
 ((* endblock *))