fix typo

converters/transformers.py

@@ -1,236 +1,236 b''
 """
 
 """
 
 from __future__ import print_function
 
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Unicode, Bool, Dict, List
 
 class ConfigurableTransformers(Configurable):
     """ A configurable transformer """
 
     def __init__(self, config=None, **kw):
         super(ConfigurableTransformers, self).__init__(config=config, **kw)
 
     def __call__(self, nb, other):
         try :
             for worksheet in nb.worksheets :
                 for index, cell in enumerate(worksheet.cells):
                     worksheet.cells[index], other = self.cell_transform(cell, other, index)
             return nb, other
         except NotImplementedError as error :
             raise NotImplementedError('should be implemented by subclass')
 
     def cell_transform(self, cell, other, index):
         """
         Overwrite if you want to apply a transformation on each cell
         """
         raise NotImplementedError('should be implemented by subclass')
 
 
 class Foobar(ConfigurableTransformers):
     message = Unicode('-- nothing', config=True)
 
 
     def cell_transform(self, cell, other, index):
         return cell, other
 
 
 def cell_preprocessor(function):
     """ wrap a function to be executed on all cells of a notebook
 
     wrapped function  parameters :
     cell  : the cell
     other : external resources
     index : index of the cell
     """
     def wrappedfunc(nb, other):
         for worksheet in nb.worksheets :
             for index, cell in enumerate(worksheet.cells):
                 worksheet.cells[index], other = function(cell, other, index)
         return nb, other
     return wrappedfunc
 
 
 @cell_preprocessor
 def haspyout_transformer(cell, other, count):
     """
     Add a haspyout flag to cell that have it
 
     Easier for templating, where you can't know in advance
     wether to write the out prompt
 
     """
     cell.type = cell.cell_type
     cell.haspyout = False
     for out in cell.get('outputs', []):
         if out.output_type == 'pyout':
             cell.haspyout = True
             break
     return cell, other
 
 
 # todo, make the key part configurable.
 
 class ExtractFigureTransformer(ConfigurableTransformers):
     enabled = Bool(False,
             config=True,
             help=""" If set to false, this transformer will be no-op """
             )
 
     extra_ext_map =  Dict({},
             config=True,
             help="""extra map to override extension based on type.
             Usefull for latex where svg will be converted to pdf before inclusion
             """
             )
     display_data_priority = List(['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg' , 'text'],
             config=True,
               help= """
                     An ordered list of prefered output type, the first
                     encounterd will usually be used when converting discarding
                     the others.
                     """
             )
 
 
     #to do change this to .format {} syntax
     key_tpl = Unicode('_fig_%02i.%s', config=True)
 
     def _get_ext(self, ext):
         if ext in self.extra_ext_map :
             return self.extra_ext_map[ext]
         return ext
 
     def _new_figure(self, data, fmt, count):
         """Create a new figure file in the given format.
 
         Returns a path relative to the input file.
         """
         figname = self.key_tpl % (count, self._get_ext(fmt))
         key     = self.key_tpl % (count, fmt)
 
         # Binary files are base64-encoded, SVG is already XML
         if fmt in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
 
         return figname, key, data
 
 
     def cell_transform(self, cell, other, count):
         if not self.enabled:
             return cell, other
         if other.get('figures',None) is None :
             other['figures']={}
         for i, out in enumerate(cell.get('outputs', [])):
             for type in self.display_data_priority:
                 if out.hasattr(type):
                     figname, key, data = self._new_figure(out[type], type, count)
                     out['key_'+type] = figname
                     other['figures'][key] = data
                     count = count+1
         return cell, other
 
 class RevealHelpTransformer(ConfigurableTransformers):
 
     section_open = False
     subsection_open = False
     fragment_open = False
 
     def open_subsection(self):
         self.subsection_open = True
         return True
 
     def open_section(self):
         self.section_open = True
         return True
 
     def open_fragment(self):
         self.fragment_open = True
         return True
 
     # could probaly write those maybe_close/open
     # with a function functor
     def maybe_close_section(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if self.section_open :
             self.section_open = False
             return True
         else :
             return False
 
     def maybe_open_section(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if not self.section_open :
             self.section_open = True
             return True
         else :
             return False
 
     def maybe_open_subsection(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if not self.subsection_open :
             self.subsection_open = True
             return True
         else :
             return False
 
     def maybe_close_subsection(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if self.subsection_open :
             self.subsection_open = False
             return True
         else :
             return False
 
     def maybe_close_fragment(self):
         """return True is already open, false otherwise
         and change state to close
         """
         if self.fragment_open :
             self.fragment_open = False
             return True
         else :
             return False
 
     def cell_transform(self, cell, other,count):
         ctype = cell.metadata.get('slideshow',{}).get('slide_type',None)
-        if ctype is None :
+        if ctype in [None, '-'] :
             cell.metadata.slideshow = {}
             cell.metadata.slideshow['slide_type'] = None
         elif ctype == 'fragment':
             cell.metadata.slideshow.close_fragment = self.maybe_close_fragment()
             cell.metadata.slideshow.close_subsection = False
             cell.metadata.slideshow.close_section = False
 
             cell.metadata.slideshow.open_section = self.maybe_open_section()
             cell.metadata.slideshow.open_subsection = self.maybe_open_subsection()
             cell.metadata.slideshow.open_fragment = self.open_fragment()
 
         elif ctype == 'subslide':
             cell.metadata.slideshow.close_fragment = self.maybe_close_fragment()
             cell.metadata.slideshow.close_subsection = self.maybe_close_subsection()
             cell.metadata.slideshow.close_section = False
 
             cell.metadata.slideshow.open_section = self.maybe_open_section()
             cell.metadata.slideshow.open_subsection = self.open_subsection()
             cell.metadata.slideshow.open_fragment = False
         elif ctype == 'slide':
             cell.metadata.slideshow.close_fragment = self.maybe_close_fragment()
             cell.metadata.slideshow.close_subsection = self.maybe_close_subsection()
             cell.metadata.slideshow.close_section = self.maybe_close_section()
 
             cell.metadata.slideshow.open_section = self.open_section()
             cell.metadata.slideshow.open_subsection = self.open_subsection()
             cell.metadata.slideshow.open_fragment = False
         return cell,other
 

templates/reveal.tpl

@@ -1,150 +1,150 b''
 {%- extends 'basichtml.tpl' -%}
 
 
 {% block any_cell -%}
 
 {% if cell.metadata.slideshow.close_fragment %}
 </div>
 {% endif %}
 {% if cell.metadata.slideshow.close_subsection %}
 </section>
 {% endif %}
 {% if cell.metadata.slideshow.close_section %}
 </section>
 {% endif %}
 
 {% if cell.metadata.slideshow.open_section %}
 <section>
 {%- endif %}
 {% if cell.metadata.slideshow.open_subsection %}
 <section>
 {%- endif %}
 {% if cell.metadata.slideshow.open_fragment %}
 <div class='fragment'>
 {% endif %}
 {% if cell.metadata.slideshow.slide_type in ['notes'] %}
 <aside class="notes">
 {{ super() }}
 </aside>
-{% elif cell.metadata.slideshow.slide_tyle not in ['skip'] %}
+{% elif cell.metadata.slideshow.slide_type not in ['skip'] %}
 {{ super() }}
 {% endif %}
 
 {% endblock %}
 
 
 {% block body %}
 <body>
 <div class="reveal"><div class="slides">
 {{ super() }}
 </section>
 </section>
 </div></div>
 
 <script src="reveal/lib/js/head.min.js"></script>
 
 <script src="reveal/js/reveal.min.js"></script>
 
 <script>
  
 // Full list of configuration options available here: https://github.com/hakimel/reveal.js#configuration
 Reveal.initialize({
 controls: true,
 progress: true,
 history: true,
 
 theme: Reveal.getQueryHash().theme, // available themes are in /css/theme
 transition: Reveal.getQueryHash().transition || 'linear', // default/cube/page/concave/zoom/linear/none
 
 // Optional libraries used to extend on reveal.js
 dependencies: [
 { src: 'reveal/lib/js/classList.js', condition: function() { return !document.body.classList; } },
 { src: 'reveal/plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
 { src: 'reveal/plugin/zoom-js/zoom.js', async: true, condition: function() { return !!document.body.classList; } },
 { src: 'notes/notes.js', async: true, condition: function() { return !!document.body.classList; } },
 { src: 'https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS_HTML', async: true },
 { src: 'js/revealmathjax.js', async: true}
 ]
 });
 </script>
 
 <script>
 Reveal.addEventListener( 'slidechanged', function( event ) {
 MathJax.Hub.Rerender(event.currentSlide);
 });
 </script>
 </body>
 </html>{% endblock body %}
 
 
 
 
 {% block header %}<!DOCTYPE html>
 <html>
 <head>
 
 <meta charset="utf-8" />
 <meta http-equiv="X-UA-Compatible" content="chrome=1">
 
 <meta name="apple-mobile-web-app-capable" content="yes" />
 <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
 
 <link rel="stylesheet" href="reveal/css/reveal.css">
 <link rel="stylesheet" href="reveal/css/theme/simple.css" id="theme">
 
 <!-- For syntax highlighting -->
 <link rel="stylesheet" href="reveal/lib/css/zenburn.css">
 
 <!-- If the query includes 'print-pdf', use the PDF print sheet -->
 <script>
 document.write( '<link rel="stylesheet" href="reveal/css/print/' + ( window.location.search.match( /print-pdf/gi ) ? 'pdf' : 'paper' ) + '.css" type="text/css" media="print">' );
 </script>
 
 <!--[if lt IE 9]>
 <script src="reveal/lib/js/html5shiv.js"></script>
 <![endif]-->
 
 {% for css in inlining.css -%}
 <style type="text/css">
 {{css}}
 </style>
 {% endfor %}
 
 <style type="text/css">
 /* Overrides of notebook CSS for static HTML export */
 
 .reveal {
   font-size: 20px;
 }
 .reveal pre {
     width: 100%;
     padding: 0.2em;
     margin: 0px auto;
     font-family: monospace, sans-serif;
     font-size: 60%;
     box-shadow: 0px 0px 0px rgba(0, 0, 0, 0);
 }
 .reveal section img {
     border: 0px solid black;
     box-shadow: 0 0 10px rgba(0, 0, 0, 0);
 }
 div.input_area {
     padding: 0.2em;
 }
 div.code_cell {
     background-color: transparent;
 }
 div.prompt {
     width: 11ex;
     padding: 0.0em;
     margin: 0px;
     font-family: monospace;
     font-size: 60%;
     text-align: center;
 }
 div.output_prompt {
     /* 5px right shift to account for margin in parent container */
     margin: 5px 5px 0 -5px;
 }
 </style>
 </head>{% endblock %}