def main(): 'main entry point' def walker(key, value, fmt, meta): 'walk down the pandoc AST and invoke workers for CodeBlocks' if key == 'CodeBlock': return dispatch(value, fmt, meta).image() elif key == 'Div': # Process Div & try to merge its (subsequent) Image's [[ident, classes, kvs], blocks] = value if not "im_merge" in classes: return None # keep it as-is classes = [x for x in classes if x != 'im_merge'] rv = [] for block in blocks: if block['t'] != 'CodeBlock': rv.append(block) else: elm = dispatch(block['c'], fmt, meta).image() rest = mergeImages(rv, elm) rv.extend(rest) return pf.Div([ident, classes, kvs], rv) dispatch = Handler(None, None, None) pf.toJSONFilter(walker)
def latex_json_filter(): r""" A Pandoc filter for additional and custom LaTeX processing functionality. .. see: pandoc_utils.latex_prefilter """ toJSONFilter(latex_prefilter)
def main(): global config config = configparser.ConfigParser() config.read(global_vars._CONFIG) toJSONFilter(parse_site)
def include(key, value, format, meta): if key == 'CodeBlock': ((id, classes, namevals), contents) = value files = [val for name, val in namevals if name == 'run'] # Use only first file. with codecs.open(files[0], 'r', 'utf8') as f: # compile and run file with given arguments return CodeBlock([id, classes, namevals], contents) if __name__ == "__main__": toJSONFilter(include)
def main(): 'main entry point' def walker(key, value, fmt, meta): 'walk down the pandoc AST and invoke workers for CodeBlocks' if key == 'CodeBlock': worker = dispatch(value).get_prefs(meta) return worker.image(fmt) dispatch = Handler(None) pf.toJSONFilter(walker)
[[ident,classes,keyvals], raw_code] = value if "r" in classes: path = os.path.dirname(os.path.abspath(__file__)) caption, typef, keyvals = get_caption(keyvals) width, keyvals = get_value(keyvals, "width", 7) height, keyvals = get_value(keyvals, "height", 7) filename = sha1(raw_code + str(width) + str(height)) src = imagedir + '/' + filename + '.png' if not os.path.isfile(src): try: os.mkdir(imagedir) except OSError: pass code = "ppi <- 100\npng('" + src + \ "', width=" + width + "*ppi, height=" + height + "*ppi, res=ppi)\n" + raw_code data, err = pipe(["R", "--no-save"], code) if (len(err) > 0): return Para([Str(err)]) try: image = Image([ident, [], keyvals], caption, [src, typef]) return Para([image]) except: try: image = Image(caption, [src, typef]) return Para([image]) except: pass if __name__ == "__main__": toJSONFilter(R)
""" Pandoc filter to convert spans with class="correction" to LaTeX \mccorrect environments in LaTeX output, and leave as is in HTML output. """ from pandocfilters import toJSONFilter, RawInline, Span def latex(x): #LaTeX inline return RawInline('latex', x) def corrections(key, value, format, meta): if key == 'Span': [[ident, classes, keyvals], contents] = value if "correction" in classes: if format == "latex": if ident == "": label = "" else: label = '\\label{' + ident + '}' return ([latex('\\colorbox[HTML]{CCCCFF}{')] + contents + [latex('}')]) if __name__ == "__main__": toJSONFilter(corrections)
def main(): toJSONFilter(mermaid)
#!/usr/bin/env python from __future__ import print_function from pandocfilters import toJSONFilter, Image, RawInline, Cite, Para, Header, Str, RawBlock, attributes, stringify import os, sys """ Pandoc metadata filter. """ def warning(*objs): print("WARNING: ", *objs, file=sys.stderr) def context(s): return RawBlock("context", s) def myheader(key, value, fmt, meta): if key == "Image" and fmt == "context": warning(value) if __name__ == "__main__": toJSONFilter(myheader)
[[ident,classes,keyvals], code] = value caption = "" if "dot" in classes: path = os.path.dirname(os.path.abspath(__file__)) filename = sha1(code) alt = Str(caption) tit = "" src = imagedir + '/' + filename + '.png' if not os.path.isfile(src): try: os.mkdir(imagedir) except OSError: pass data, err = pipe(["dot", "-Tpng", "-s100"], code) if (len(err) > 0): return Para([Str(err)]) with open(src, 'w') as f: f.write(data) try: image = Image(attributes({}), [alt], [src,tit]) return Para([image]) except: try: image = Image([alt], [src, tit]) return Para([image]) except: pass if __name__ == "__main__": toJSONFilter(graphviz)
global base_url, version global count if key == 'Math': # grab equation par = False if value[0]['t'] == 'InlineMath': formula = '$' + value[1] + '$' caption = value[1] else: par = True formula = r'\begin{align*}' + value[1] + r'\end{align*}' caption = '' # typeset formula count += 1 latex(formula, count) # replace by image return Image(['', [], []], [Str(caption)], [base_url + version + '/eqn_{}.png'.format(count), '']) if __name__ == "__main__": count = 0 # filter toJSONFilter(filter)
def plantuml(key, value, format, _): if key == 'CodeBlock': [[ident, classes, keyvals], code] = value if "plantuml" in classes: caption, typef, keyvals = get_caption(keyvals) filename = get_filename4code("plantuml", code) filetype = get_extension(format, "png", html="svg", latex="eps") src = filename + '.uml' dest = filename + '.' + filetype if not os.path.isfile(dest): txt = code.encode(sys.getfilesystemencoding()) if not txt.startswith("@start"): txt = "@startuml\n" + txt + "\n@enduml\n" with open(src, "w") as f: f.write(txt) call(["java", "-jar", "plantuml.jar", "-t" + filetype, src]) sys.stderr.write('Created image ' + dest + '\n') return Para([Image([ident, [], keyvals], caption, [dest, typef])]) if __name__ == "__main__": toJSONFilter(plantuml)
#!/usr/bin/python # -*- coding: utf-8 -*- from pandocfilters import toJSONFilter def process(key, value, format, meta): # find images and change their src paths to relative ones if key == 'Image': src = value[1][0] value[1][0] = '../images/' + src.split('/')[-1] # find links to old uploads and change their href paths to relative ones if key == 'Link': href = value[1][0] if 'programminghistorian.org/wp-content/uploads/' in href: value[1][0] = '../images/' + href.split('/')[-1] if __name__ == "__main__": toJSONFilter(process)
key type of pandoc object value contents of pandoc object format target output format meta document metadata ''' if format != 'latex': return # Determine what kind of code object this is. if key == 'CodeBlock': template = Template( '\\begin{minted}[$attributes]{$language}\n$contents\n\end{minted}' ) Element = RawBlock elif key == 'Code': template = Template('\\mintinline[$attributes]{$language}{$contents}') Element = RawInline else: return settings = unpack_metadata(meta) code = unpack_code(value, settings['language']) return [Element(format, template.substitute(code))] if __name__ == '__main__': toJSONFilter(minted)
#!/usr/bin/env python """ Pandoc filter for assisting with html output """ from pandocfilters import toJSONFilter, RawBlock, Div def latex(x): return RawBlock('latex', x) def latexdivs(key, value, format, meta): if key == 'Div': [[ident, classes, kvs], contents] = value if ["latex","true"] in kvs: if format == "latex": if ident == "": label = "" else: label = '\\label{' + ident + '}' return([latex('\\begin{quotation}\\textbf{' + ident + '}')] + contents + [latex('\\end{quotation}')]) if __name__ == "__main__": toJSONFilter(latexdivs)
else: highlightLineNumbersArray = [] if highlightCharacter is None: highlightCharacter = "*" if shouldTrimWhitespace is None: shouldTrimWhitespace = False elif shouldTrimWhitespace == "trim": shouldTrimWhitespace = True else: shouldTrimWhitespace = False # Use the extension as the code block type extension = os.path.splitext(filename)[1].replace(".", "") if extension == "hql": # Change HiveQL to SQL extension = "sql" elif extension == "m": # Change m to Objective C extension = "objectivec" elif extension == "h": # Change m to Objective C extension = "objectivec" return CodeBlock(['', [extension], []], processIncludeLine(filename, includeLineNumbersArray, highlightLineNumbersArray, highlightCharacter, shouldTrimWhitespace)) if __name__ == "__main__": toJSONFilter(includesource)
GITHUB_URL = "https://github.com/cjerdonek/open-rcv/blob/master/" PYPI_URL = "https://pypi.python.org/pypi/OpenRCV/" log = logging.getLogger(__file__) def convert_url(url): """Convert URL appearing in a markdown file to a new URL. Returns None if URL should remain same. """ parsed_url = urlparse(url) log.debug(repr(parsed_url)) url_path = parsed_url[2] if not url_path: # Then we assume it is a fragment. new_url = urlunparse(parsed_url) new_url = urljoin(PYPI_URL, new_url) return new_url if (not url_path.endswith(".md") and url_path != "LICENSE"): return None # Otherwise, we link back to the original GitHub pages. new_url = urlunparse(parsed_url) new_url = urljoin(GITHUB_URL, new_url) return new_url if __name__ == "__main__": toJSONFilter(init_action(convert_url))
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ## # Increments all headers by 1 level to a maximum of 6 levels. # import os import sys from pandocfilters import toJSONFilter, Header LEVELS = 1 MAX_LEVEL = 6 def inc_header(key, value, format, _): if key == 'Header': [level, attr, inline] = value if level + LEVELS <= MAX_LEVEL: level += LEVELS return Header(level, attr, inline) if __name__ == "__main__": toJSONFilter(inc_header)
#!/usr/bin/env python from pandocfilters import toJSONFilter, RawInline """ Pandoc filter that causes emphasis to be rendered using the custom macro '\myemph{...}' rather than '\emph{...}' in latex. Other output formats are unaffected. """ def latex(s): return RawInline('latex', s) def myemph(k, v, f, meta): if k == 'Emph' and f == 'latex': return [latex('\\myemph{')] + v + [latex('}')] if __name__ == "__main__": toJSONFilter(myemph)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Pandoc filter to convert divs with class to LaTeX environments of the same name. """ import sys from urllib.parse import urlparse from pandocfilters import toJSONFilter, Link def internallinks(key, value, format, meta): if key == 'Link': [attrs, contents, [url, title]] = value o = urlparse(url) if not o.scheme and not o.netloc and o.fragment: url = '#' + o.fragment return Link(attrs, contents, (url, title)) if __name__ == "__main__": toJSONFilter(internallinks)
return RawInline('context', s) def mycite(key, value, fmt, meta): if key == 'Cite' and fmt == 'context': [[kvs], [contents]] = value #kvs = {key: value for key, value in kvs} if "fig:" in kvs['citationId'] or "tab:" in kvs['citationId']: return [context("\in[")]+[context(kvs['citationId'])] + [context(']')] else: return [context("\\cite[")] +[context(kvs['citationId'])] + [context(']')] # if key == 'Header' and fmt == 'context': # #warning(key) # #warning(value) # [level, contents, kvs] = value # if level == 1 and contents == ['references',[],[]]: # return RawBlock('context', "\completepublications") if __name__ == "__main__": toJSONFilter(mycite)
os.chdir(olddir) shutil.copyfile(tmpdir + '/temp.' + filetype, outfile + '.' + filetype) shutil.rmtree(tmpdir) def asy(key, value, format, meta): if key == 'CodeBlock': [[ident, classes, keyvals], code] = value caption = "caption" if "asy" in classes: outfile = imagedir + '/' + sha1(code) if format == "html": filetype = "png" elif format == "latex": filetype = "pdf" else: filetype = "png" src = outfile + '.' + filetype if not os.path.isfile(src): try: os.mkdir(imagedir) sys.stderr.write('Created directory ' + imagedir + '\n') except OSError: pass asy2image(code, filetype, outfile) sys.stderr.write('Created image ' + src + '\n') return Para([Image([], [src, ""])]) if __name__ == "__main__": toJSONFilter(asy)
shutil.rmtree(tmpdir) def tikz(key, value, format, meta): # if key == 'RawBlock': # [fmt, code] = value # if fmt == "latex" and re.match("\\\\begin{tikzpicture}", code): if key == 'CodeBlock': [[ident, classes, keyvals], code] = value if "tikz" in classes: outfile = imagedir + '/' + sha1(code) if format == "html": filetype = "png" elif format == "latex": filetype = "pdf" else: filetype = "png" src = outfile + '.' + filetype if not os.path.isfile(src): try: os.mkdir(imagedir) sys.stderr.write('Created directory ' + imagedir + '\n') except OSError: pass tikz2image(code, filetype, outfile) sys.stderr.write('Created image ' + src + '\n') return Para([Image([], [src, ""])]) if __name__ == "__main__": toJSONFilter(tikz)
#!/usr/bin/env python3 import pandocfilters as pf def latex(s): return pf.RawBlock('latex', s) def mk_centered(k, v, f, m): if k == "Para": value = pf.stringify(v) if value.startswith('[') and value.endswith(']'): content = value[1:-1] if content == "center": return latex(r'\begin{center}') elif content == "/center": return latex(r'\end{center}') if __name__ == "__main__": pf.toJSONFilter(mk_centered)
def configure_logging(): format_string = "%(name)s: [%(levelname)s] %(message)s" logging.basicConfig(format=format_string, level=logging.DEBUG) #log.debug("Debug logging enabled.") def IsNumber(x): import re if re.match("^\d*.?\d*$", x) == None: return False return True def behead(key, value, format, meta): if format == 'latex': if key == 'Str': try: # if there is no exception this is english text value.encode('ascii') # Just change non numeric values if not IsNumber(value): if value not in ignored_words: return RawInline('latex', '\\lr{'+value+'}') except UnicodeEncodeError: #log.info( "string is UTF-8") pass if __name__ == "__main__": configure_logging() toJSONFilter(behead)
def main(): toJSONFilter(plantuml)
#!/usr/bin/env python """ Pandoc filter to allow interpolation of metadata fields into a document. %{fields} will be replaced by the field's value, assuming it is of the type MetaInlines or MetaString. """ from pandocfilters import toJSONFilter, attributes, Span, Str import re pattern = re.compile('%\{(.*)\}$') def metavars(key, value, format, meta): if key == 'Str': m = pattern.match(value) if m: field = m.group(1) result = meta.get(field, {}) if 'MetaInlines' in result['t']: return Span(attributes({'class': 'interpolated', 'field': field}), result['c']) elif 'MetaString' in result['t']: return Str(result['c']) if __name__ == "__main__": toJSONFilter(metavars)
#!/usr/bin/env python from pandocfilters import toJSONFilter, CodeBlock, Image, Para, Str from matplotlib.pyplot import savefig import uuid from pylab import rcParams rcParams['figure.figsize'] = 2, 2 def evalR(key, value, fmt, meta): if key == 'CodeBlock' and value[0][1][0] == "python": figfile = "%s.png" % (uuid.uuid4()) exec(value[1]) savefig(figfile) return Para([Image([Str("Output")], [figfile, "fig:"])]) if __name__ == "__main__": toJSONFilter(evalR)
math = [alignHtmlMath(x) for x in math] if ident != '': label = ['id=\"' + x + '\" ' for x in id] else: label = id head = [html('<table class=\"' + ' '.join(classes) + '\" ' + \ ' '.join(kvs) + '>' + "\n")] tail = [html('</table>' + "\n")] body = [html('<tbody>' + "\n")] for (i, eq) in enumerate(math): body = body + [html('<tr>' + "\n")] for sub in [formatHtmlMath(y, ident != '') for y in eq]: body = body + sub if ident != '': body = body + [html(' <td ' + label[i] + 'class=\"eq_number\"> <br>(' + eqNumber(id[i]) + ')<br> </td>')] body = body + [html('</tr>' + "\n")] body = body + [html('</tbody>' + "\n")] return head + body + tail if key == 'Span': [[ident,classes,kvs], contents] = value if 'eq_ref' in classes: if format == 'latex': return latexInline("(" + "\\ref{" + ident + "})") if format == 'html' or format == 'html5': return htmlInline("(<a href=#" + ident + ">" + eqNumber(ident) + "</a>)") if __name__ == '__main__': toJSONFilter(equation)
if key == 'Header': lbl = value[1][0] if lbl: new_lbl = ".. _" + lbl + ":\n\n" value[1][0] = "" store(key, value) return [rb(new_lbl), Header(value[0], value[1], value[2])] # fix two bugs with string parsing elif key == 'Str': # pandoc does not parse \xpsace correctly -> insert whitespace after CAF if last_element == ('Str', 'CAF') and value.isalnum(): store(key, value) return [Space(), Str(value)] if len(value) > 3: # pandoc generates [refname] as strings for \ref{refname} -> fix if value[0] == '[': store(key, value) return mk_ref(value[1:-1]) elif value[1] == '[': store(key, value) return mk_ref(value[2:-1]) # images don't have file endings in .tex -> add .png elif key == 'Image': store(key, value) return Image(value[0], value[1], [value[2][0] + ".png", value[2][1]]) store(key, value) if __name__ == "__main__": toJSONFilter(behead)
#!/usr/bin/python from pandocfilters import toJSONFilter, stringify, Link def duck(key, value, format_, meta): ''' If a link is of the form "!STRING", use the !-expression to search DuckDuckGo. So for instance [Fishmans](!w) would search Wikipedia for "Fishmans". ''' if key == 'Link': [txt, [url, attr]] = value if url.startswith("!"): url = "http://duckduckgo.com/?q=" + url + " " + stringify(txt) return Link(txt, [url, attr]) if __name__ == '__main__': toJSONFilter(duck)
""" Pandoc filter to allow interpolation of metadata fields into a document. %{fields} will be replaced by the field's value, assuming it is of the type MetaInlines or MetaString. """ from pandocfilters import toJSONFilter, attributes, Span, Str import re pattern = re.compile('%\{(.*)\}$') def metavars(key, value, format, meta): if key == 'Str': m = pattern.match(value) if m: field = m.group(1) result = meta.get(field, {}) if 'MetaInlines' in result: return Span( attributes({ 'class': 'interpolated', 'field': field }), result['MetaInlines']) elif 'MetaString' in result: return Str(result['MetaString']) if __name__ == "__main__": toJSONFilter(metavars)
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ from pandocfilters import toJSONFilter, RawBlock, Div def latex(x): return RawBlock('latex', x) def lois(key, value, format, meta): if key == 'Div': [[ident, classes, kvs], contents] = value if "loi" in classes: if format == "latex": if ident == "": label = "" else: label = '\\label{' + ident + '}' return([latex('\\begin{loi}' + label)] + contents + [latex('\\end{loi}')]) elif format == "html" or format == "html5": newcontents = [html('<div class="loi"><blockquote> ' + contents + '</blockquote></div>')] return Div([ident, classes, kvs], newcontents) if __name__ == "__main__": toJSONFilter(lois)
if "graphviz" in classes: G = pygraphviz.AGraph(string=code) layout = "dot" for elem in keyvals: if elem[0] == "layout": layout = elem[1] G.layout(layout) filename = sha1(code) if format == "html": filetype = "png" elif format == "latex": filetype = "pdf" else: filetype = "png" alt = Str(caption) src = imagedir + '/' + filename + '.' + filetype if not os.path.isfile(src): try: os.mkdir(imagedir) except OSError: pass G.draw(src) out(src) tit = "" return Para([Image(['', [], []], [alt], [src, tit])]) if __name__ == "__main__": toJSONFilter(graphviz)
````{raw=latex} \usepackage{pgfpages} \pgfpagesuselayout{2 on 1}[a4paper] ```` ... See <https://github.com/jgm/pandoc/issues/2139> """ from pandocfilters import RawInline, RawBlock, toJSONFilter from pandocattributes import PandocAttributes raw4code = {'Code': RawInline, 'CodeBlock': RawBlock} def code2raw(key, val, format, meta): if key not in raw4code: return None attrs = PandocAttributes(val[0], format='pandoc') raw = attrs.kvs.get('raw', None) if raw: # if raw != format: # but what if we output markdown? # return [] return raw4code[key](raw, val[-1]) else: return None if __name__ == "__main__": toJSONFilter(code2raw)
#!/usr/bin/env python """ Pandoc filter to convert all regular text to uppercase. Code, link URLs, etc. are not affected. """ from pandocfilters import toJSONFilter, Str, RawInline, Code def latex(s): return RawInline('latex', s) def caps(key, value, format, meta): if key == 'Str' and value == "->": return latex("$\\rightarrow$") if __name__ == "__main__": toJSONFilter(caps)
from pandocfilters import toJSONFilter, Str, RawBlock import re from itertools import islice def getLines(attrs): lines_re = re.match("(\d+)-(\d+)", attrs.get('lines', "")) if lines_re: return (int(lines_re.group(1)), int(lines_re.group(2)) + 1) return (0, None) def wpmath(key, value, format, meta): if key == "Math": return Str("$LaTeX " + value[1] + "$") if key == "CodeBlock": language = value[0][1] attrs = dict(value[0][2]) if 'fromFile' in attrs: with open(attrs['fromFile']) as codeFile: return RawBlock(value[0], '\n'.join(islice(codeFile, *getLines(attrs)))) #print value #return RawBlock(value[0], str(value[1])) if __name__ == "__main__": toJSONFilter(wpmath)
FLAG_PAT = re.compile('.*\{(\d+\.?\d?)\}') def wrapfig(key, val, fmt, meta): if key == 'Image': attrs, caption, target = val if FLAG_PAT.match(stringify(caption)): # Strip tag size = FLAG_PAT.match(caption[-1]['c']).group(1) stripped_caption = caption[:-2] if fmt == 'latex': latex_begin = r'\begin{wrapfigure}{r}{' + size + 'in}' if len(stripped_caption) > 0: latex_fig = r'\centering\includegraphics{' + target[0] \ + '}\caption{' latex_end = r'}\end{wrapfigure}' return [RawInline(fmt, latex_begin + latex_fig)] \ + stripped_caption + [RawInline(fmt, latex_end)] else: latex_fig = r'\centering\includegraphics{' + target[0] \ + '}' latex_end = r'\end{wrapfigure}' return [RawInline(fmt, latex_begin + latex_fig)] \ + [RawInline(fmt, latex_end)] else: return Image(attrs, stripped_caption, target) if __name__ == '__main__': toJSONFilter(wrapfig) sys.stdout.flush() # Should fix issue #1 (pipe error)
elif "include" in classes: caption, typef, keyvals = get_caption(keyvals) keyvalDict = dict(keyvals) listing = '' with open( keyvalDict['src'], 'r' ) as f: listing = f.read() lang = keyvalDict.get( 'lang', 'python') code = 'Failed to find any listing.' if 'start' in keyvalDict: # Assume that both start and end are line numbers. start = int( keyvalDict['start'] ) end = int( keyvalDict['end'] ) code = '\n'.join( listing.split('\n')[start:end] ) elif 'pat' in keyvalDict: pat = r'%s' % keyvalDict['pat'] print1( pat ) m = re.search( pat, listing, re.DOTALL ) if m: code = m.group(0) else: code = "Pattern '%s' not found in '%s'" % (pat, keyvalDict['src']) else: code = 'No listing found.' return CodeBlock([ident, [], keyvals], code) if __name__ == "__main__": toJSONFilter( codeblocks )
def main(): environment = Environment() pdf.toJSONFilter(environment.convert)
Pandoc filter that causes everything between '<!-- BEGIN SOLUTION -->' and '<!-- END SOLUTION -->' to be ignored. The comment lines must appear on lines by themselves, with blank lines surrounding them. """ from pandocfilters import toJSONFilter import re incomment = False def comment(k, v, fmt, meta): global incomment if k in ['RawBlock', 'RawInline']: fmt, s = v if fmt == "html": if re.search("<!-- BEGIN SOLUTION -->", s): incomment = True return [] elif re.search("<!-- END SOLUTION -->", s): incomment = False return [] if incomment: return [] # suppress anything in a comment if __name__ == "__main__": toJSONFilter(comment)
def svg_to_any(key, value, fmt, meta): if key == "Image": if len(value) == 2: # before pandoc 1.16 alt, [src, title] = value attrs = None else: attrs, alt, [src, title] = value mimet, _ = mimetypes.guess_type(src) option = fmt_to_option.get(fmt) if mimet == "image/svg+xml" and option: base_name, _ = os.path.splitext(src) eps_name = base_name + "." + option try: mtime = os.path.getmtime(eps_name) except OSError: mtime = -1 if mtime < os.path.getmtime(src): cmd_line = ["cairosvg", "-f", option, "-o", eps_name, src] sys.stderr.write("Running %s\n" % " ".join(cmd_line)) subprocess.call(cmd_line, stdout=sys.stderr.fileno()) if attrs: return Image(attrs, alt, [eps_name, title]) else: return Image(alt, [eps_name, title]) if __name__ == "__main__": toJSONFilter(svg_to_any)
# a blockquote is just a list of blocks, so it can be # passed directly to Div, which expects Div(attr, blocks) return pf.Div((id, classes, kvs), [panel_header, panel_body]) if __name__ == '__main__': # pandocfilters.toJSONFilter is a convenience method that # makes a command line json filter from a given function. # JSON emitted from pandoc is read from stdin. The JSON tree is # walked, with the function being applied to each element in the # tree. # # The function passed to to JSONFilter must accept (key, value, # format, metadata) as arguments: # # key - element type (e.g. 'Str', 'Header') # value - element contents # format - destination format # metadata - document metadata # # The function return values determine what happens to the # element: # returns None: the element is unmodified; # returns []: delete the element # otherwise: replace the element with the return value # # The JSON is then output to stdout, where it can be consumed by # pandoc. pf.toJSONFilter(blockquote2div)
block("\placetable[here][%s]{%s}{" % (strCap[0][0], strCap[0][1]))) out.append(block("\\bTABLE")) if not empty(head): out.append( block( "\setupTABLE[r][1][background=color,backgroundcolor=gray,style={\\tfa}]" )) out.append(block("\\bTR")) for h in head: out.append(block("\\bTH %s \\eTH" % (stringify(h)))) out.append(block("\\eTR")) else: out.append( block( "\setupTABLE[r][1][background=color,backgroundcolor=white,style={\\tfx}]" )) for row in text: out.append(block("\\bTR")) for cell in row: out.append(block("\\bTD %s \\eTD" % stringify(cell))) out.append(block("\\eTR")) out.append(block("\\eTABLE}")) return out if __name__ == "__main__": toJSONFilter(crossreference)
meta: document metadata """ if format == "html": if key == 'CodeBlock': body, language, params, source_file = unpack(value, meta) if language is None: return if source_file is None: html = '<pre><code class="language-%s">%s</code></pre>' % (language, body) return [RawBlock(format, html)] else: content = r'\inputminted[' + params + ']{' + language + '}{' + source_file + '}' return [RawBlock(format, content)] elif key == 'Code': body, language, params, source_file = unpack(value, meta) if language is None: return html = '<code class="language-%s">%s</code>' % (language, body) return [RawInline(format, html)] if __name__ == '__main__': # import sys # sys.stdin = open("test.json") toJSONFilter(prism)
g = {'output': None} def get_image(src): outfilename = str(get_filename4code('temp-plantuml', src, 'png')) file = open(outfilename, 'w') p = subprocess.Popen(['plantuml', '-p', '-tpng'], stdin=subprocess.PIPE, stdout=file) p.stdin.write(src.encode('UTF-8')) p.communicate() p.stdin.close() return outfilename def index(key, value, format, meta): if key == 'CodeBlock': [[ident, classes, kvs], contents] = value caption, typef, kvs = get_caption(kvs) if 'plantuml' in classes and 'embed' in classes: return Para([ Image( [ident, [], kvs], caption, [get_image(contents), typef] ) ]) if __name__ == "__main__": toJSONFilter(index)
# if len(value) == 2: # url = Str( value[-1][0] ) # name = Str( ' '.join([ # return Link([' '.join([ walk( val, deconcat, format, meta ) for val in value ])], [ url ] ) # if key == 'Str': # return Str( value ) # elif key == 'Space': # return Space([ ]) def pchecko(key, value, format, meta): logging.debug('HUUU %s: %s' % (key, value)) def imStuff(key, value, format, meta): if key == 'Image': logging.debug('%s: %s, %d' % (key, value[-1], len(value))) # return walk(value[-1], pchecko, format, meta ) #[[ident, classes, kvs], contents] = value #logging.debug('CLASSES: %s' % classes ) caption, location = value # now concatenate the content logging.debug('%s: content = %s, %d' % (key, caption, len(caption))) return Image([Str("hello")], [location[0], location[1]]) if __name__ == '__main__': logging.basicConfig(filename='removewidths_filter.log', level=logging.DEBUG) toJSONFilter(imStuff)
#!/usr/bin/env python from pandocfilters import toJSONFilter, RawInline, stringify import re align = re.compile("\\\\begin{align}") def math(k, v, f, meta): if k == 'Math' and f == 'latex' and re.search(align, v[1]): return RawInline('latex', v[1]) if __name__ == "__main__": toJSONFilter(math)
"beamer": ("--export-pdf", "pdf"), # because of IE "html": ("--export-png", "png") } def svg_to_any(key, value, fmt, meta): if key == 'Image': attrs, alt, [src, title] = value mimet, _ = mimetypes.guess_type(src) option = fmt_to_option.get(fmt, ("--export-pdf", "pdf")) if mimet == 'image/svg+xml' and option: base_name, _ = os.path.splitext(src) eps_name = base_name + "." + option[1] eps_name = eps_name.replace("%20", "") src = src.replace("%20", " ") try: mtime = os.path.getmtime(eps_name) except OSError: mtime = -1 if mtime < os.path.getmtime(src): cmd_line = ['inkscape', option[0], eps_name, src] sys.stderr.write("Running %s\n" % " ".join(cmd_line)) subprocess.call(cmd_line, stdout=sys.stderr.fileno()) return Image(attrs, alt, [eps_name.replace("%20", " "), title]) if __name__ == "__main__": toJSONFilter(svg_to_any)
#!/usr/bin/env python3 from pandocfilters import toJSONFilter, Math, Para """Pandoc filter to convert gitlab flavored markdown to pandoc flavored markdown""" def gitlab_markdown(key, value, format, meta): if key == "CodeBlock": [[identification, classes, keyvals], code] = value if classes[0] == "math": fmt = {'t': 'DisplayMath', 'c': []} return Para([Math(fmt, code)]) elif key == "Math": [fmt, code] = value if isinstance(fmt, dict) and 't' in fmt.keys(): if fmt['t'] == "InlineMath": return Math(fmt, code.strip('`')) if __name__ == "__main__": toJSONFilter(gitlab_markdown)
result.extend(para) result[-1] = inlatex(r' \\ \hline' '\n') return pf.Para(result) def do_filter(k, v, f, m): if k == "Table": # Ensure every alignment characters is surrounded by a pipes. # Get the string of the alignment characters # and split into an array for every characters. split_alignment = [c for c in tbl_alignment(v[1])] # Join this list into a single string with pipe symbols # between them, plus pipes at start and end. # This results in a boxed table. new_alignment = "|" + "|".join(split_alignment) + "|" return [ latex(r'\begin{table}[h]'), latex(r'\centering'), latex(r'\begin{tabular}{%s} \hline' % new_alignment), tbl_headers(v[3]), tbl_contents(v[4]), latex(r'\end{tabular}'), # Put the caption after the tabular so it appears under table. tbl_caption(v[0]), latex(r'\end{table}') ] if __name__ == "__main__": pf.toJSONFilter(do_filter)
#!/usr/bin/env python """ Pandoc filters to customise the HTML / LaTeX output when parsing documents. To figure out what elements are and how to edit them run pandoc -f markdown -t json project_overview.md and have a look at the (very very long) JSON output. """ from pandocfilters import toJSONFilter, Image, Str, RawInline # Replace [tick] or [cross] with different icons in PDF and HTML def tick_cross_images (key, value, format, meta): if key == 'Str' and value == '[tick]': if format == "latex": return RawInline('latex', r'~\tickmark~~') else: return RawInline('html', r'<span class="icon_tick">✔</span> ') if key == 'Str' and value == '[cross]': if format == "latex": return RawInline('latex', r'~\crossmark~~~') else: return RawInline('html', r'<span class="icon_cross">✘</span> ') if __name__ == "__main__": toJSONFilter(tick_cross_images)
code = doc.read().split('%%\n')[1] return [ Image([], [ png(contents, latexsnippet('\\gregorioscore', kvs)), "" ]) ] elif key == 'CodeBlock': [[ident, classes, kvs], contents] = value kvs = {key: value for key, value in kvs} if "gabc" in classes: if fmt == "latex": if ident == "": label = "" else: label = '\\label{' + ident + '}' return [ latexblock("\n\\smallskip\n{%\n" + latexsnippet('\\gabcsnippet{' + contents + '}', kvs) + "%\n}" + label) ] else: return Para([ Image([], [ png(contents, latexsnippet('\\gabcsnippet', kvs)), "" ]) ]) if __name__ == "__main__": toJSONFilter(gabc)
if format == 'latex': if key == 'Image': options = {key: val for key, val in value[0][2]} image_name = value[2][0] width = float(options.get("w", .9)) caption = None if len(value[1]) > 0: capt = value[1] caption = "" for part in capt: if part["t"] == "Str": caption += part["c"] elif part["t"] == "Space": caption += " " content = center_image(image_name, caption, width) return [RawInline(format, content)] if key == 'Header' and len(value[1][2]) > 0: options = {key: val for key, val in value[1][2]} if "magic" in options and options["magic"] in MAGIC_OPTIONS[format]: magic_func = MAGIC_OPTIONS[format][options["magic"]] return magic_func(format, options) if __name__ == '__main__': # sys.stdin = open("test.json") # testing only toJSONFilter(parse)
#!/usr/bin/env python """ Pandoc filter that: - removes backticks within InlineMath contents """ from pandocfilters import toJSONFilter, Math import re STRIP_BACKTICKS_RE = re.compile(r'^`(?P<contents>.*)`$', re.MULTILINE | re.UNICODE | re.DOTALL) def cleanup(k, v, fmt, meta): if k in ['Math']: if fmt in ['latex', 'beamer', 'json', 'html5']: math_type = v[0].get('t', None) if math_type in [u'InlineMath'] and len(v) > 1: solution_match = STRIP_BACKTICKS_RE.search(v[1]) if solution_match: return Math(v[0], solution_match.group('contents')) if __name__ == "__main__": toJSONFilter(cleanup)
else: c.append(a) if found: label = stringify_maths(b).split(" ")[0].lower() lower = ext.lower() if last_precedent_header: return [latex(r"\begin{" + lower + "}[" + stringify_maths(b) + "]"), pf.Para(c), latex(r"\label{" + label + "}"), latex(r"\end{" + lower + "}")] else: return [latex(r"\vspace{3mm}"), latex(r"\begin{" + lower + "}[" + stringify_maths(b) + "]"), pf.Para(c), latex(r"\label{" + label + "}"), latex(r"\end{" + lower + "}")] t = deal_extension("Theorem") if t == None: t = deal_extension("Lemma") if t == None: t = deal_extension("Property") if t == None: return deal_extension("Definition") else: return t else: return t else: return t if __name__ == "__main__": pf.toJSONFilter(mk_columns)
Image(['', [], []], [], [png(code, kvs), ""] ) ] if key == 'CodeBlock': [[ident, classes, kvs], code] = value kvs = {key: value for key, value in kvs} if "ly" in classes: kvs = calc_params(kvs, meta) if fmt == "latex": if ident == "": label = "" else: label = '\\label{' + ident + '}' return latexblock( '\\lily[staffsize=%s]{%s}' % (kvs['staffsize'], code) + label ) else: return Para([ Image( ['', [], []], [], [png(code, kvs), ""] ) ]) if __name__ == "__main__": toJSONFilter(lily)
def latex(s): return pf.RawBlock('latex', s) def mk_columns(k, v, f, m): if k == "Para": value = pf.stringify(v) if value.startswith('[') and value.endswith(']'): content = value[1:-1] if content == "columns": if f == "beamer": return latex(r'\begin{columns}') elif f == "latex": return latex(r'\begin{multicols}{2}') elif content == "/columns": if f == "beamer": return latex(r'\end{columns}') elif f == "latex": return latex(r'\end{multicols}') elif content.startswith("column="): if f == "beamer": return latex(r'\column{%s\textwidth}' % content[7:]) elif f == "latex": return latex(r'\columnbreak') if __name__ == "__main__": pf.toJSONFilter(mk_columns)
folder = el[1] if "objects" in el or "object" in el: objdiv = "--" obj = "%s %s" % (obj, el[1]) if "diffoptions" == el[0]: options = el[1] command_string = "git -C %s diff %s %s %s %s" % ( folder, options, commra, objdiv, obj) out = "" try: l = list(filter(None, command_string.split(" "))) out = subprocess.check_output(l) except subprocess.CalledProcessError as err: return None if out != None or out != "": out = out.decode("utf-8") return [ CodeBlock([ident, classes, keyvals], out), CodeBlock([ident, classes, keyvals], contents) ] else: return None if __name__ == "__main__": toJSONFilter(gitdiff)