def test_pypandoc_compatibility(self): """ This test is testing if org-mode can be converted to html via pypandoc """ from_formats, to_formats = pypandoc.get_pandoc_formats() self.assertTrue('org' in from_formats) self.assertTrue('html5' in to_formats)
def test_pypandoc_compatibility(self): """ This test is testing if org-mode can be converted to html via pypandoc """ from_formats, to_formats = pypandoc.get_pandoc_formats() self.assertTrue(u'org' in from_formats) self.assertTrue(u'html5' in to_formats)
def convert(ctx, name, destination_format, destination_file, list_docs, formats): """Convert to destination_format and print to stdout or save to file if provided.""" # yew = ctx.obj["YEW"] if formats or not destination_format: formats = pypandoc.get_pandoc_formats() click.echo("Input formats:") for f in formats[0]: click.echo("\t" + f) click.echo("Output formats:") for f in formats[1]: click.echo("\t" + f) sys.exit(0) docs = shared.get_document_selection(ctx, name, list_docs) if not docs: sys.exit(1) doc = docs[0] click.echo(doc.name) click.echo(doc.kind) click.echo(destination_format) if destination_format in ["docx", "pdf", "odt"]: destination_file = "{}.{}".format(slugify(doc.name), destination_format) if destination_file: dest = pypandoc.convert( doc.get_content(), format=doc.kind, to=destination_format, outputfile=destination_file, ) click.echo(destination_file) else: dest = pypandoc.convert_text(doc.get_content(), format=doc.kind, to=destination_format) click.echo(dest) sys.stdout.flush()
import os, datetime from django.template import loader, Template, Context from django.conf import settings from django.utils import html from asena.views import token_protect import logging, pprint logger = logging.getLogger(__name__) try: import pypandoc pypandoc.get_pandoc_formats() PANDOC_AVAILABLE=True except OSError as e: logger.warn(e) PANDOC_AVAILABLE=False PANDOC_AVAILABLE=False DEFAULT_DATE_FORMAT='%Y%m%d_%H%M%S' def _get_default_filename(): now = datetime.datetime.now() snow = now.strftime(DEFAULT_DATE_FORMAT) return 'resume_%s'%(snow) def write_rst(request, rst_template, context, filename=None): if not filename: filename = _get_default_filename()
def create_header(): header = "<name>SOG Atrium Backup</name>\n" header += "<description>Migrated Atrium Data importable to XWiki</description>\n" header += "<licence>Not public</licence>\n" header += "<author>XWiki.Atrium</author>\n" return header def create_page_files(pages): for page in pages: # check for folders on path formal_path = page.build_prefixed_path().replace(".", "/") physical_path = output_folder_path + "/" + formal_path print("Creating XWiki Page %s" % formal_path) if not os.path.exists(physical_path): os.makedirs(physical_path) xml_tree_string = page.build_xml_content_file() f = open(physical_path + "/WebHome.xml", "w") f.write(xml_tree_string.decode('utf-8')) f.close() if __name__ == "__main__": if not os.path.exists(output_folder_path): os.makedirs(output_folder_path) print(pypandoc.get_pandoc_formats()[1]) initialize() convert_atrium_db_to_xar()
def parse_args(sysargv): pandocInputFormats, pandocOutputFormats = pypandoc.get_pandoc_formats() parser = argparse.ArgumentParser( prog='easyblogger', description="Easily manage posts on Blogger blogs", fromfile_prefix_chars='@') parser.add_argument("-i", "--clientid", help="Your API Client id", default="132424086208.apps.googleusercontent.com") parser.add_argument("-s", "--secret", help="Your API Client secret", default="DKEk2rvDKGDAigx9q9jpkyqI") parser.add_argument( "-v", "--verbose", help="verbosity(log level) - default CRITICAL", choices=["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"], type=str.upper, default="CRITICAL") group = parser.add_mutually_exclusive_group() group.add_argument("--blogid", help="Your blog id") group.add_argument("--url", help="Your blog url") subparsers = parser.add_subparsers(help="sub-command help", dest="command") get_parser = subparsers.add_parser("get", help="list posts") group = get_parser.add_mutually_exclusive_group() group.add_argument("-p", "--postId", help="the post id") group.add_argument("-l", "--labels", help="comma separated list of labels", type=toUnicode) group.add_argument("-q", "--query", help="search term", type=toUnicode) group.add_argument("-u", help="the full post url", metavar="URL", type=toUnicode) output_format = get_parser.add_mutually_exclusive_group() output_format.add_argument("-f", "--fields", help="fields to output", default="id,title,url") output_format.add_argument( "-d", "--doc", help="""Output as document - use one of the output formats supported by pandoc: """ + ", ".join(pandocOutputFormats)) get_parser.add_argument( "-w", "--write-files", dest='tofiles', help="write output files (only used with --doc). " + "True if more than one post is retrieved", action="store_true") get_parser.add_argument("--legacy-frontmatter", dest='legacyFrontmatter', help="use legacy front matter format (deprecated)", action="store_true") get_parser.add_argument("-c", "--count", type=int, help="count") post_parser = subparsers.add_parser("post", help="create a new post") post_parser.add_argument("-t", "--title", help="Post title", type=toUnicode) post_parser.add_argument("-l", "--labels", help="comma separated list of labels", type=toUnicode) post_parser.add_argument("--publish", action="store_true", help="Publish to the blog [default: false]") post_parser.add_argument("--date", dest='publishDate', help="Publish date (ISO8601) of the post - ex:" + "2018-01-01T10:00:00+05:30") post_input = post_parser.add_mutually_exclusive_group(required=True) post_input.add_argument("-c", "--content", help="Post content", type=toUnicode) post_input.add_argument("-f", "--file", type=argparse.FileType('r'), help="Post content - input file") post_parser.add_argument("--filters", nargs="+", default=[], help="pandoc filters") post_parser.add_argument("--format", help="Content format: " + ", ".join(pandocInputFormats), choices=pandocInputFormats, default="html") delete_parser = subparsers.add_parser("delete", help="delete a post") delete_parser.add_argument("postIds", nargs="+", help="the post to delete") update_parser = subparsers.add_parser("update", help="update a post") update_parser.add_argument("postId", help="the post to update") update_parser.add_argument("-t", "--title", help="Post title") update_parser.add_argument( "--date", dest='publishDate', help="Publish date (ISO8601) of the post - ex:" + "2018-01-01T10:00:00+05:30") update_input = update_parser.add_mutually_exclusive_group() update_input.add_argument("-c", "--content", help="Post content") update_input.add_argument("-f", "--file", type=argparse.FileType('r'), help="Post content - input file") update_parser.add_argument("--format", help="Content format: " + ", ".join(pandocInputFormats), choices=pandocInputFormats, default="html") update_parser.add_argument("-l", "--labels", help="comma separated list of labels", type=toUnicode) update_parser.add_argument("--publish", action="store_true", help="Publish to the blog [default: false]") update_parser.add_argument("--filters", nargs="+", default=[], help="pandoc filters") file_parser = subparsers.add_parser( "file", help="Figure out what to do from the input file") file_parser.add_argument("file", nargs="+", help="Post content - input file") config = os.path.expanduser("~/.easyblogger") if (os.path.exists(config)): sysargv = ["@" + config] + sysargv args = parser.parse_args(sysargv) verbosity = logging.getLevelName(args.verbose) # print(verbosity, logging.getLevelName(verbosity)) coloredlogs.install(verbosity) if args.verbose != "critical": logger.setLevel(logging.INFO) logger.info("setting log level to: %s ", args.verbose) logger.setLevel(verbosity) logger.debug("Final args:") logger.debug(sysargv) return args
def configure(): """ Perform initial setup. """ config = { 'sync_interval': 300 } generate_key = not click.confirm("Do you already have an API key for " "zotero-cli?") if generate_key: (config['api_key'], config['library_id']) = ZoteroBackend.create_api_key() else: config['api_key'] = click.prompt( "Please enter the API key for zotero-cli") config['library_id'] = click.prompt("Please enter your library ID") sync_method = select( [("local", "Local Zotero storage"), ("zotcoud", "Use Zotero file cloud"), ("webdav", "Use WebDAV storage")], default=1, required=True, prompt="How do you want to access files for reading?") if sync_method == "local": storage_dirs = tuple(find_storage_directories()) if storage_dirs: options = [(name, "{} ({})".format(click.style(name, fg="cyan"), path)) for name, path in storage_dirs] config['storage_dir'] = select( options, required=False, prompt="Please select a storage directory (-1 to enter " "manually)") if config.get('storage_dir') is None: click.echo( "Could not automatically locate a Zotero storage directory.") while True: storage_dir = click.prompt( "Please enter the path to your Zotero storage directory", default='') if not storage_dir: storage_dir = None break elif not os.path.exists(storage_dir): click.echo("Directory does not exist!") elif not re.match(r'.*storage/?', storage_dir): click.echo("Path must point to a `storage` directory!") else: config['storage_dir'] = storage_dir break elif sync_method == "webdav": while True: if not config.get('webdav_path'): config['webdav_path'] = click.prompt( "Please enter the WebDAV URL") if not config.get('webdav_user'): config['webdav_user'] = click.prompt( "Please enter the WebDAV user name") config['webdav_pass'] = click.prompt( "Please enter the WebDAV password") try: test_resp = requests.get( config['webdav_path'], auth=(config['webdav_user'], config['webdav_pass'])) except requests.ConnectionError: click.echo("Invalid WebDAV URL, could not reach server.") config['webdav_path'] = None continue if test_resp.status_code == 501: break elif test_resp.status_code == 404: click.echo("Invalid WebDAV path, does not exist.") config['webdav_path'] = None elif test_resp.status_code == 401: click.echo("Bad credentials.") config['webdav_user'] = None else: click.echo("Unknown error, please check your settings.") config['webdav_path'] = None config['webdav_user'] = None config['sync_method'] = sync_method markup_formats = pypandoc.get_pandoc_formats()[0] config['note_format'] = select(zip(markup_formats, markup_formats), default=markup_formats.index('markdown'), prompt="Select markup format for notes") save_config(config) zot = ZoteroBackend(config['api_key'], config['library_id'], 'user') click.echo("Initializing local index...") num_synced = zot.synchronize() click.echo("Synchronized {} items.".format(num_synced))
def store_file(filename, store_root=STORE_ROOT, store_dirfmt=STORE_DIRFMT, pandoc_fnfmt="{store_dir}/{stem}.md", add_lstat=True, add_hash='md5', verbose=2): inputfn_attrs = get_filename_attrs(filename) store_dir = os.path.join(store_root, store_dirfmt).format(store_root=store_root, **inputfn_attrs) if verbose and verbose > 0: print("Creating store %r for file %r" % (store_dir, filename)) config = DEFAULT_METADATA.copy() archive_dir = os.path.join(store_dir, config['archive']) os.makedirs(archive_dir) config['inputfn'] = filename if add_hash: if add_hash is True: add_hash = HASH_METHOD config['hash_method'] = add_hash config['hash_hexdigest'] = hash_file(filename) if add_lstat: # (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) # Do not include atime, it is frequently updated (e.g. by search indexing). lstat = os.lstat(filename) stat_attrs = ( 'st_size', # size, in bytes 'st_ctime', 'st_ctime_ns', # time of creation (Windows) or change (Unix) 'st_mtime', 'st_mtime_ns', # time of modificaton. 'st_nlink', 'st_dev', 'st_ino', # device, inode 'st_mode', 'st_uid', 'st_gid', # filemode, user id, group id, # 'st_flags', 'st_gen', # user-defined flags, generation, ) config['lstat'] = {a: getattr(lstat, a, 0) for a in stat_attrs} # list(lstat) try: with zipfile.ZipFile(filename, 'r') as zipfd: zipfd.extractall(archive_dir) except zipfile.BadZipfile: import tempfile with tempfile.TemporaryDirectory() as tempdir: tempfn = os.path.join(tempdir, inputfn_attrs['name']) print("Copying %r -> %r" % (filename, tempfn)) shutil.copyfile(filename, tempfn) with zipfile.ZipFile(tempfn, 'r') as zipfd: zipfd.extractall(archive_dir) if pandoc_fnfmt: pandoc_supported_formats = pypandoc.get_pandoc_formats() # from, to if isinstance(pandoc_fnfmt, str): pandoc_fnfmt = [pandoc_fnfmt] for output_fnfmt in pandoc_fnfmt: pandoc_fn = output_fnfmt.format(store_root=store_root, store_dir=store_dir, **inputfn_attrs) assert '.' in pandoc_fn output_format = pandoc_fn.rsplit('.')[-1] # if output_format not in pandoc_supported_formats[0]: # print(" - Output format %r not supported by Pandoc!" % output_format) # elif inputfn_attrs['filetype'] not in pandoc_supported_formats[1]: # print(" - Input format %r not supported by Pandoc!" % inputfn_attrs['filetype']) # else: try: if verbose and verbose > 1: print(" - Making %s file: %r -> %r" % (output_format, filename, pandoc_fn)) pypandoc.convert_file(filename, output_format, outputfile=pandoc_fn) except RuntimeError as exc: print(" - Could not convert with pandoc: %s" % (exc, )) metadata_fn = os.path.join(store_dir, FILE_METADATA_FN) with open(metadata_fn, 'w') as fp: yaml.dump(config, fp, default_flow_style=False)
def get_pandoc_formats(): import pypandoc return pypandoc.get_pandoc_formats()
def output_format(self, output_format): if not (output_format in pypandoc.get_pandoc_formats()[1]): raise ValueError( '{} is not supported like output format'.format(output_format)) self._output_format = output_format
def input_format(self, input_format): if not (input_format in pypandoc.get_pandoc_formats()[0]): raise ValueError( '{} is not supported like input formats'.format(input_format)) self._input_format = input_format
def index(): _, output_formats = pypandoc.get_pandoc_formats() return render_template("index.html", output_formats=output_formats)
class ConvertTextParams(BaseModel): source: str = Field(None, description= 'Unicode string or bytes (see encoding)') to: str = Field(..., description= 'format into which the input should be convertedcan be one of {}'.format(pypandoc.get_pandoc_formats()[1])) format: str= Field(..., description='the format of the inputs; can be one of {}'.format(pypandoc.get_pandoc_formats()[1])) extra_args: List[str] = Field((), description='extra arguments (list of strings) to be passed to pandoc (Default value = ())') encoding: str = Field('utf-8', description="the encoding of the input bytes (Default value = 'utf-8')") filters: List[str] = Field(None, description="pandoc filters e.g. filters=['pandoc-citeproc']")
from pydantic import BaseModel, Field from typing import List import pypandoc from enum import Enum available_format = pypandoc.get_pandoc_formats()[1] class ConvertTextParams(BaseModel): source: str = Field(None, description= 'Unicode string or bytes (see encoding)') to: str = Field(..., description= 'format into which the input should be convertedcan be one of {}'.format(pypandoc.get_pandoc_formats()[1])) format: str= Field(..., description='the format of the inputs; can be one of {}'.format(pypandoc.get_pandoc_formats()[1])) extra_args: List[str] = Field((), description='extra arguments (list of strings) to be passed to pandoc (Default value = ())') encoding: str = Field('utf-8', description="the encoding of the input bytes (Default value = 'utf-8')") filters: List[str] = Field(None, description="pandoc filters e.g. filters=['pandoc-citeproc']")
#!/usr/bin/env python from distutils.core import setup # Read README for long description readme = open('README').read() try: import pypandoc pypandoc.get_pandoc_formats() readme = pypandoc.convert(readme, to='rst', format='markdown') except: pass with open('pylibscrypt/__init__.py') as f: for l in f.readlines(): if l.startswith('__version__'): version = l.split('=')[1].strip().strip("'") setup( name='pylibscrypt', version=version, description='Scrypt for Python', long_description=readme, author='Jan Varho', author_email='*****@*****.**', url='https://github.com/jvarho/pylibscrypt', license='ISC License', packages=['pylibscrypt'], classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers',
def query(self, todays=None, bdays=None, otype=None, ext=None, att_get=None, att_max=None, mail=None, first=None, sort_case=None, sort_rules=None): """Query Gmail e-mail for specified date Kwargs: todays: Date to query (e.g. 2016-01-01; default today) bdays: Days back to look for e-mail. mail: Give yourself e-mail notification with query results ext: Email file extension (default blank) Returns: Output todays email to specified output folder and prints or e-mails message with query results. """ if bdays is None: bdays = self.cfg_args.bdays if otype is None: otype = self.cfg_args.otype if ext is None: ext = self.cfg_args.ext if att_get is None: att_get = self.cfg_args.att_get if att_max is None: att_max = self.cfg_args.att_max if mail is None: mail = self.cfg_args.mail if first is None: first = self.cfg_args.first if sort_case is None: sort_case = self.cfg_args.sort_case if sort_rules is None: sort_rules = self.cfg_args.sort_file ptypes = pandoc.get_pandoc_formats()[1] if otype not in ptypes and not otype == 'eml': raise Warning("Output type must be: {}".format(', '.join(ptypes))) max_size = parse_string(att_max) if att_get else None sort = sort_rules != '' # Get date to query, recursively create output dir # ------------------------------------------------ todays = todays if todays else str(datetime.date.today()) outdir = os.path.join(self.outdir, todays) self.finaldir = outdir mkdir_recursive(outdir) # Query Gmail # ----------- try: df = self.query_todays(todays, bdays, first, otype, max_size) except: df = None res = "Gmail query FAILED" ext = ext_dict[otype] if ext == '' else ext if df is not None: print_df_query(df, outdir, self.tzstr, otype, ext) if sort: if os.path.isfile(sort_rules): try: self.sort_query(sort_rules, sort_case) except: print("Sorting failed. Check '{}'".format(sort_rules)) else: print("'{}' not found. Can't sort.".format(sort_rules)) res = "Success! See output folder:" + os.linesep + outdir else: res = 'No e-mail %s' % todays # Report success/fail # ------------------- if mail: msg = [ "Content-Type: text/plain; charset=\"UTF-8\"", "MIME-Version: 1.0", "Content-Transfer-Encoding: message/rfc2822", "To: <%s>" % self.outmail, "From: <%s>" % self.outmail, "Subject: Mail Dump for %s" % todays, "", res ] b = base64.b64encode(os.linesep.join(msg)) b = b.replace('+', '-').replace('/', '_') self.messages.insert(userId='me', body={'raw': b}).execute() else: print(res)
def test_get_pandoc_formats(self): inputs, outputs = pypandoc.get_pandoc_formats() self.assertTrue("markdown" in inputs) self.assertTrue("json" in inputs) self.assertTrue("twiki" in inputs) self.assertTrue("markdown" in outputs)
import logging import pathlib import re import shutil import tarfile import zipfile from pathlib import Path from typing import Union, IO, Any import pypandoc logger = logging.getLogger('asyncio') __FORMATS = pypandoc.get_pandoc_formats() PANDOC_SERVICE_INPUT_FORMATS = frozenset(__FORMATS[0]) PANDOC_SERVICE_OUTPUT_FORMATS = frozenset(['pdf'] + __FORMATS[1]) PANDOC_SERVICE_FORMATS = frozenset(PANDOC_SERVICE_INPUT_FORMATS | PANDOC_SERVICE_OUTPUT_FORMATS) class ExtractArchiveError(Exception): pass class NotAnArchiveError(ExtractArchiveError): pass
import pypandoc from .mkcException import mkcException (from_formats,to_formats) = pypandoc.get_pandoc_formats() class StrLang(object): """Class defining a string, PLUS mention of its lang (ie LaTeX, Markdown, etc.)""" def __init__(self, string, lang=None): if lang is not None and lang not in from_formats: raise mkcException( "The lang "+ lang+" cannot be converted by Pandoc.") self.string=string self.lang=lang def convertTo(self, lang=None): if lang is not None and lang not in to_formats: raise mkcException( "The string '"+self.string+"' cannot be converted to "+lang+" by Pandoc ('"+lang+"' is not supported).") if lang is not None and self.lang != lang and self.lang is not None: return pypandoc.convert( self.string, format=self.lang, to=lang) else: return self.string def __str__(self): return self.string
def configure(): """ Perform initial setup. """ config = {'sync_interval': 300} generate_key = not click.confirm("Do you already have an API key for " "zotero-cli?") if generate_key: (config['api_key'], config['library_id']) = ZoteroBackend.create_api_key() else: config['api_key'] = click.prompt( "Please enter the API key for zotero-cli") config['library_id'] = click.prompt("Please enter your library ID") sync_method = select([("local", "Local Zotero storage"), ("zotcoud", "Use Zotero file cloud"), ("webdav", "Use WebDAV storage")], default=1, required=True, prompt="How do you want to access files for reading?") if sync_method == "local": storage_dirs = tuple(find_storage_directories()) if storage_dirs: options = [(name, "{} ({})".format(click.style(name, fg="cyan"), path)) for name, path in storage_dirs] config['storage_dir'] = select( options, required=False, prompt="Please select a storage directory (-1 to enter " "manually)") if config.get('storage_dir') is None: click.echo( "Could not automatically locate a Zotero storage directory.") while True: storage_dir = click.prompt( "Please enter the path to your Zotero storage directory", default='') if not storage_dir: storage_dir = None break elif not os.path.exists(storage_dir): click.echo("Directory does not exist!") elif not re.match(r'.*storage/?', storage_dir): click.echo("Path must point to a `storage` directory!") else: config['storage_dir'] = storage_dir break elif sync_method == "webdav": while True: if not config.get('webdav_path'): config['webdav_path'] = click.prompt( "Please enter the WebDAV URL (without '/zotero'!)") if not config.get('webdav_user'): config['webdav_user'] = click.prompt( "Please enter the WebDAV user name") config['webdav_pass'] = click.prompt( "Please enter the WebDAV password") try: test_resp = requests.options(config['webdav_path'], auth=(config['webdav_user'], config['webdav_pass'])) except requests.ConnectionError: click.echo("Invalid WebDAV URL, could not reach server.") config['webdav_path'] = None continue if test_resp.status_code == 200: break elif test_resp.status_code == 404: click.echo("Invalid WebDAV path, does not exist.") config['webdav_path'] = None elif test_resp.status_code == 401: click.echo("Bad credentials.") config['webdav_user'] = None else: click.echo("Unknown error, please check your settings.") click.echo("Server response code was: {}".format( test_resp.status_code)) config['webdav_path'] = None config['webdav_user'] = None config['sync_method'] = sync_method markup_formats = pypandoc.get_pandoc_formats()[0] config['note_format'] = select(zip(markup_formats, markup_formats), default=markup_formats.index('markdown'), prompt="Select markup format for notes") save_config(config) zot = ZoteroBackend(config['api_key'], config['library_id'], 'user') click.echo("Initializing local index...") num_synced = zot.synchronize() click.echo("Synchronized {} items.".format(num_synced))
import pypandoc from .mkcException import mkcException (from_formats, to_formats) = pypandoc.get_pandoc_formats() class StrLang(object): """Class defining a string, PLUS mention of its lang (ie LaTeX, Markdown, etc.)""" def __init__(self, string, lang=None): if lang is not None and lang not in from_formats: raise mkcException("The lang " + lang + " cannot be converted by Pandoc.") self.string = string self.lang = lang def convertTo(self, lang=None): if lang is not None and lang not in to_formats: raise mkcException("The string '" + self.string + "' cannot be converted to " + lang + " by Pandoc ('" + lang + "' is not supported).") if lang is not None and self.lang != lang and self.lang is not None: return pypandoc.convert(self.string, format=self.lang, to=lang) else: return self.string def __str__(self): return self.string