def apply_loading_format_extra_arguments_parser(parser):
import sys
import argparse
from importlib import import_module
from dictknife.cliutils.extraarguments import ExtraArgumentsParsers
from dictknife import loading
formats = loading.get_formats()
ex_parsers = ExtraArgumentsParsers(parser, "--output-format") # xxx:
mixed_parser = argparse.ArgumentParser(conflict_handler="resolve")
for f in formats:
if f == "markdown": # xxx:
continue
m = import_module("dictknife.loading.{f}".format(f=f))
ex_parser = ex_parsers.add_parser(f)
setup = getattr(m, "setup_extra_parser", None)
if setup is None:
print(
"{m.__name__} doesn't have setup_extra_parser() function".
format(m=m),
file=sys.stderr,
)
continue
setup(ex_parser)
# xxx: Action has state (not copyable) , so, re-setup by setup function
# for ac in ex_parser._actions:
# mixed_parser._add_action(new_ac)
setup(mixed_parser)
original = parser.parse_known_args
def parse_known_args(*args, **kwargs):
parsed, rest = original(*args, **kwargs)
transformed_rest = ex_parsers._transform_args(rest)
_, unexpected = mixed_parser.parse_known_args(
transformed_rest, namespace=argparse.Namespace())
if unexpected:
return parsed, unexpected # xxx:
if parsed.output_format is None:
parsed.output_format = (
parsed.format or loading.get_unknown().__name__.split(".")[-1])
if parsed.dst is not None:
parsed.output_format = loading.guess_format(parsed.dst)
ex_parsed = ex_parsers._parse_args(parsed.output_format,
transformed_rest)
parsed.extra = dict(vars(ex_parsed))
return parsed, []
parser.parse_known_args = parse_known_args
def main():
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="subcommand")
subparsers.required = True
fn = cat
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("-f", "--format", choices=loading.get_formats())
apply_loading_format_extra_arguments_parser(sparser)
args = parser.parse_args()
params = dict(vars(args))
params.pop("subcommand")(**params)
def main():
import argparse
from colorama import init
init()
parser = argparse.ArgumentParser()
parser.add_argument("-m", "--module", default="zenmai.actions")
parser.add_argument("--driver", default="zenmai.driver:Driver")
parser.add_argument("--debug", action="store_true")
parser.add_argument("--logging", default="INFO", choices=list(logging._nameToLevel.keys()))
parser.add_argument("-f", "--format", default=None, choices=loading.get_formats())
parser.add_argument("--data", action="append")
parser.add_argument("--select", default=None)
parser.add_argument("file", default=None)
loading.setup()
args = parser.parse_args()
module = import_module(args.module)
data = [loadfile_with_jsonref(path) for path in args.data or []]
def wrap(d):
if args.select is None:
return d
return access_by_json_pointer(d, args.select.split("#")[-1])
driver_cls = import_symbol(args.driver, ns="zenmai.driver")
driver = driver_cls(module, args.file, format=args.format, data=data)
# todo: option
logging.basicConfig(
format="%(levelname)5s:%(name)30s:%(message)s",
level=logging._nameToLevel[args.logging]
)
try:
if args.file is None:
driver.run(sys.stdin, sys.stdout, wrap=wrap)
else:
with open(args.file) as rf:
driver.run(rf, sys.stdout, wrap=wrap)
except Exception as e:
if args.debug:
raise
print("{errcolor}{e.__class__.__name__}:{reset} {e}".format(e=e, errcolor=colorama.Fore.YELLOW, reset=colorama.Style.RESET_ALL))
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("src", nargs="?", default=None)
parser.add_argument("--format",
choices=loading.get_formats(),
default=None)
parser.add_argument("--dst",
default=sys.stdout,
type=argparse.FileType("w"))
parser.add_argument("--ref", default=None)
parser.add_argument("--package", default=None)
parser.add_argument("--file", default="main.go")
parser.add_argument("--position", default=None)
parser.add_argument("--walker",
default="goaway.commands.swagger2go:Walker")
parser.add_argument("--writer", default="goaway.writer:Writer")
parser.add_argument("--emitter", default="goaway.emitter:Emitter")
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
loading.setup()
r = get_repository(
writer_cls=import_symbol(args.writer),
emitter_cls=import_symbol(args.emitter),
)
doc = loading.loadfile(args.src)
package = r.package(args.package or "main")
walker_cls = import_symbol(args.walker)
walker = walker_cls(doc, package.file(args.file), r)
if args.ref:
walker.walk_ref(args.ref)
else:
walker.walk_all()
d = r.resolve_package_path(args.position, package)
r.emitter.emit_package(package, d=d)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("src",
nargs="?",
type=argparse.FileType("r"),
default=sys.stdin)
parser.add_argument("--logging",
default="INFO",
choices=list(logging._nameToLevel.keys()))
parser.add_argument("-f",
"--format",
default=None,
choices=loading.get_formats())
parser.add_argument("--position", default=None)
args = parser.parse_args()
setup()
logging.basicConfig(format="%(levelname)5s\t%(name)10s\t%(message)s",
level=logging._nameToLevel[args.logging])
d = loading.load(args.src, format=args.format)
emitfiles(transform(d), format=args.format, position=args.position or ".")
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data", action="append", help="support yaml, json, toml", default=[]
)
parser.add_argument(
"--loader",
default="kamidana.loader:TemplateLoader",
help="default: kamidana.loader:TemplateLoader",
)
parser.add_argument(
"--logging", choices=list(logging._nameToLevel.keys()), default="INFO"
)
parser.add_argument("-a", "--additionals", action="append", default=[])
parser.add_argument("-e", "--extension", action="append", default=[])
parser.add_argument("-i", "--input-format", default=None, choices=get_formats())
parser.add_argument("-o", "--output-format", default="raw")
parser.add_argument("--debug", action="store_true")
parser.add_argument("--quiet", action="store_true")
parser.add_argument("batch")
parser.add_argument("--outdir", default=None)
args = parser.parse_args()
logging.basicConfig(level=getattr(logging, args.logging))
with error_handler(debug=args.debug, quiet=args.quiet):
loader_cls = import_symbol(args.loader, ns="kamidana.loader", cwd=True)
extensions = [
("jinja2.ext.{}".format(ext) if "." not in ext else ext)
for ext in args.extension
]
loader = loader_cls(
args.data, args.additionals, extensions, format=args.input_format
)
driver_cls = import_symbol("kamidana.driver:BatchCommandDriver", cwd=True)
driver = driver_cls(loader, format=args.output_format)
driver.run(args.batch, args.outdir)
def main():
import argparse
formats = loading.get_formats()
parser = argparse.ArgumentParser(
formatter_class=type(
"_HelpFormatter",
(argparse.ArgumentDefaultsHelpFormatter, argparse.RawTextHelpFormatter),
{},
)
)
parser.print_usage = parser.print_help # hack
parser.add_argument(
"--log",
choices=list(logging._nameToLevel.keys()),
default="INFO",
dest="log_level",
help="-",
)
parser.add_argument("-q", "--quiet", action="store_true", help="-")
parser.add_argument("--debug", action="store_true", help="-")
# modification
parser.add_argument(
"--compact", action="store_true", dest="modification_compact", help="-"
)
parser.add_argument(
"--flatten", action="store_true", dest="modification_flatten", help="-"
)
parser.add_argument(
"--unescape",
default=None,
dest="modification_unescape",
choices=["unicode", "url"],
help="-",
)
subparsers = parser.add_subparsers(dest="subcommand", title="subcommands")
subparsers.required = True
# cat
fn = cat
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
apply_loading_format_extra_arguments_parser(sparser)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("files", nargs="*", default=[sys.stdin], help="-")
sparser.add_argument("--slurp", action="store_true", help="-")
sparser.add_argument("--size", type=int, default=None, help="-")
sparser.add_argument("--dst", default=None, help="-")
sparser.add_argument("-f", "--format", default=None, choices=formats, help="-")
sparser.add_argument(
"-i", "--input-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"-o", "--output-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"--encoding", help="input encoding. (e.g. utf-8, cp932, ...)", default=None,
)
sparser.add_argument(
"--errors",
default=None,
choices=[
"strict",
"ignore",
"replace",
"surrogateescape",
"xmlcharrefreplace",
"backslashreplace",
"namereplace",
],
help="see pydoc codecs.Codec",
)
sparser.add_argument("-S", "--sort-keys", action="store_true", help="-")
sparser.add_argument(
"--merge-method",
choices=["addtoset", "append", "merge", "replace"],
default="addtoset",
help="-",
)
# transform
fn = transform
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
def print_help(*, file=None, self=sparser):
if file is None:
file = sys.stdout
# overwrite help
for ac in self._actions:
if ac.dest == "functions":
import dictknife.transform as m
callables = [
k
for k, v in m.__dict__.items()
if not k.startswith("_") and callable(v)
]
ac.help = "(e.g. {}, ... or <module>:<fn name> (e.g. dictknife.transform:flatten))".format(
", ".join(sorted(callables))
)
self._print_message(self.format_help(), file)
sparser.print_help = print_help
sparser.set_defaults(subcommand=fn)
sparser.add_argument("src", nargs="?", help="-")
sparser.add_argument("--dst", default=None, help="-")
sparser.add_argument("--code", default=None, help="-")
sparser.add_argument(
"--fn", "--function", default=[], action="append", dest="functions", help="-"
)
sparser.add_argument(
"-i", "--input-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"-o", "--output-format", default=None, choices=formats, help="-"
)
sparser.add_argument("-f", "--format", default=None, choices=formats, help="-")
sparser.add_argument("-S", "--sort-keys", action="store_true", help="-")
# diff
fn = diff
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--normalize", action="store_true", help="-")
sparser.add_argument("--verbose", action="store_true", help="-")
sparser.add_argument("left", help="-")
sparser.add_argument("right", help="-")
sparser.add_argument("--n", default=3, type=int, help="-")
sparser.add_argument("--skip-empty", action="store_true", help="-")
sparser.add_argument(
"-i", "--input-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"-o",
"--output-format",
choices=["diff", "dict", "md", "tsv", "jsonpatch"],
default="diff",
help="-",
)
sparser.add_argument("-S", "--sort-keys", action="store_true", help="-")
# shape
fn = shape
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("files", nargs="*", default=[sys.stdin], help="-")
sparser.add_argument("--squash", action="store_true", help="-")
sparser.add_argument("--skiplist", action="store_true", help="-")
sparser.add_argument("--full", action="store_true", help="-")
sparser.add_argument("--with-type", action="store_true", help="-")
sparser.add_argument("--with-example", action="store_true", help="-")
sparser.add_argument("--separator", default="/", help="-")
sparser.add_argument(
"-i", "--input-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"-o", "--output-format", default=None, choices=formats, help="-"
)
# shrink
fn = shrink
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("files", nargs="*", default=[sys.stdin], help="-")
sparser.add_argument("--max-length-of-string", type=int, default=100, help="-")
sparser.add_argument("--max-length-of-list", type=int, default=3, help="-")
sparser.add_argument("--cont-suffix", default="...", help="-")
sparser.add_argument("--with-tail", action="store_true", help="-")
sparser.add_argument(
"-i", "--input-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"-o", "--output-format", default=None, choices=formats, help="-"
)
# mkdict
fn = mkdict
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
apply_rest_arguments_as_extra_arguments_parser(sparser)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--squash", action="store_true", help="-")
sparser.add_argument(
"-o", "--output-format", default="json", choices=formats, help="-"
)
sparser.add_argument("--separator", default="/", help="-")
sparser.add_argument("--delimiter", default=";", help="-")
sparser.add_argument("-S", "--sort-keys", action="store_true", help="-")
args = parser.parse_args()
params = vars(args)
with contextlib.ExitStack() as s:
if params.pop("quiet"):
args.log_level = logging._levelToName[logging.WARNING]
s.enter_context(warnings.catch_warnings())
warnings.simplefilter("ignore")
logging.basicConfig(level=getattr(logging, params.pop("log_level")))
with traceback_shortly(params.pop("debug")):
# apply modification
for k in list(params.keys()):
if k.startswith("modification_"):
v = params.pop(k)
if v:
from importlib import import_module
if isinstance(v, str):
module_path = "dictknife.loading.{}_{}".format(
k.replace("_", "."), v
)
else:
module_path = "dictknife.loading.{}".format(
k.replace("_", ".")
)
logger.info("apply %s.setup()", module_path)
m = import_module(module_path)
if not hasattr(m, "setup"):
raise RuntimeError(
"{}:setup() is not found".format(module_path)
)
m.setup(loading.dispatcher)
return params.pop("subcommand")(**params)
def main():
import argparse
formats = loading.get_formats()
parser = argparse.ArgumentParser()
parser.print_usage = parser.print_help # hack
parser.add_argument(
"--log",
choices=list(logging._nameToLevel.keys()),
default="INFO",
dest="log_level",
)
parser.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("--debug", action="store_true")
subparsers = parser.add_subparsers(dest="subcommand")
subparsers.required = True
# cut
fn = cut
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--src", default=None)
sparser.add_argument("--dst", default=None)
sparser.add_argument("--ref", dest="refs", action="append")
# deref
fn = deref
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--src", default=None)
sparser.add_argument("--dst", default=None)
sparser.add_argument("--ref", dest="refs", action="append")
sparser.add_argument("--unwrap", default=None)
sparser.add_argument("--wrap", default=None)
sparser.add_argument("-f", "--format", default=None, choices=formats)
sparser.add_argument("-i", "--input-format", default=None, choices=formats)
sparser.add_argument("-o",
"--output-format",
default=None,
choices=formats)
# select
fn = select
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--src", default=None)
sparser.add_argument("--dst", default=None)
sparser.add_argument("--ref", dest="refs", action="append")
sparser.add_argument("--unwrap", default=None)
sparser.add_argument("--wrap", default=None)
sparser.add_argument("-f", "--format", default=None, choices=formats)
sparser.add_argument("-i", "--input-format", default=None, choices=formats)
sparser.add_argument("-o",
"--output-format",
default=None,
choices=formats)
# bundle
fn = bundle
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--src", default=None)
sparser.add_argument("--dst", default=None)
sparser.add_argument("--ref", default=None)
sparser.add_argument("--flavor",
choices=["openapiv3", "openapiv2"],
default="openapiv3")
sparser.add_argument("-f", "--format", default=None, choices=formats)
sparser.add_argument("-i", "--input-format", default=None, choices=formats)
sparser.add_argument("-o",
"--output-format",
default=None,
choices=formats)
sparser.add_argument("--extra", default=None, nargs="+", dest="extras")
# separate
fn = separate
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--src", default=None)
sparser.add_argument("--dst", default=None)
sparser.add_argument("-f", "--format", default=None, choices=formats)
sparser.add_argument("-i", "--input-format", default=None, choices=formats)
sparser.add_argument("-o",
"--output-format",
default=None,
choices=formats)
# examples
fn = examples
sparser = subparsers.add_parser(fn.__name__, description=fn.__doc__)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("src", nargs="?", default=None)
sparser.add_argument("--dst", default=None)
sparser.add_argument("--ref", dest="ref", default=None)
sparser.add_argument("--limit", dest="limit", default=5, type=int)
sparser.add_argument("--expand", dest="use_expand", action="store_true")
sparser.add_argument("-f", "--format", default=None, choices=formats)
sparser.add_argument("-i", "--input-format", default=None, choices=formats)
sparser.add_argument("-o",
"--output-format",
default=None,
choices=formats)
args = parser.parse_args()
with contextlib.ExitStack() as s:
params = vars(args)
if params.pop("quiet"):
args.log_level = logging._levelToName[logging.WARNING]
s.enter_context(warnings.catch_warnings())
warnings.simplefilter("ignore")
logging.basicConfig(level=getattr(logging, params.pop("log_level")))
with traceback_shortly(params.pop("debug")):
return params.pop("subcommand")(**params)
def main():
import argparse
formats = loading.get_formats()
parser = argparse.ArgumentParser(
formatter_class=type(
"_HelpFormatter",
(argparse.ArgumentDefaultsHelpFormatter, argparse.RawTextHelpFormatter),
{},
)
)
parser.print_usage = parser.print_help # hack
parser.add_argument(
"--log",
choices=list(logging._nameToLevel.keys()),
default="INFO",
dest="log_level",
help="-",
)
parser.add_argument("-q", "--quiet", action="store_true", help="-")
parser.add_argument("--debug", action="store_true", help="-")
subparsers = parser.add_subparsers(dest="subcommand", title="subcommands")
subparsers.required = True
# merge
fn = merge
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("files", nargs="*", default=None, help="-")
sparser.add_argument("--dst", default=None, help="-")
sparser.add_argument("--strict", action="store_true", help="-")
sparser.add_argument("--style", default="ref", choices=["ref", "whole"], help="-")
sparser.add_argument("--wrap", default=None, help="-")
sparser.add_argument("--wrap-section", default="definitions", help="-")
# tojsonschema
fn = tojsonschema
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("--src", default=None, help="-")
sparser.add_argument("--dst", default=None, help="-")
sparser.add_argument("--name", default="top", help="-")
# json2swagger
fn = json2swagger
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("files", nargs="*", default=None, help="-")
sparser.add_argument("--dst", default=None, help="-")
sparser.add_argument(
"-o", "--output-format", default=None, choices=formats, help="-"
)
sparser.add_argument("--name", default="top", help="-")
sparser.add_argument("--detector", default="Detector", help="-")
sparser.add_argument("--emitter", default="Emitter", help="-")
sparser.add_argument("--annotate", default=None, help="-")
sparser.add_argument(
"--emit", default="schema", choices=["schema", "info"], help="-"
)
sparser.add_argument("--with-minimap", action="store_true", help="-")
sparser.add_argument("--without-example", action="store_true", help="-")
# flatten
fn = flatten
sparser = subparsers.add_parser(
fn.__name__, help=fn.__doc__, formatter_class=parser.formatter_class
)
sparser.set_defaults(subcommand=fn)
sparser.add_argument("src", nargs="?", default=None, help="-")
sparser.add_argument("--dst", default=None, help="-")
sparser.add_argument(
"-i", "--input-format", default=None, choices=formats, help="-"
)
sparser.add_argument(
"-o", "--output-format", default=None, choices=formats, help="-"
)
sparser.add_argument("-f", "--format", default=None, choices=formats, help="-")
args = parser.parse_args()
with contextlib.ExitStack() as s:
params = vars(args)
if params.pop("quiet"):
args.log_level = logging._levelToName[logging.WARNING]
s.enter_context(warnings.catch_warnings())
warnings.simplefilter("ignore")
logging.basicConfig(level=getattr(logging, params.pop("log_level")))
with traceback_shortly(params.pop("debug")):
return params.pop("subcommand")(**params)
import sys
import argparse
from dictknife import loading
from dictknife.cliutils.extraaguments import ExtraArgumentsParsers
from importlib import import_module
formats = loading.get_formats()
parser = argparse.ArgumentParser()
parser.add_argument("-f", "--format", choices=formats, default="json")
ex_parsers = ExtraArgumentsParsers(parser, "--format")
for f in formats:
if f == "markdown": # xxx:
continue
m = import_module(f"dictknife.loading.{f}")
ex_parser = ex_parsers.add_parser(f)
setup = getattr(m, "setup_parser", None)
if setup is None:
print(f"{m.__name__} doesn't have setup_parser() function", file=sys.stderr)
continue
setup(ex_parser)
args, rest = parser.parse_known_args()
extra, _ = ex_parsers.parse_args(args.format, rest)
print(args, extra)
L = [
{
"name": "foo",
import sys
import argparse
from dictknife import loading
from dictknife.cliutils.extraaguments import ExtraArgumentsParsers
from importlib import import_module
formats = loading.get_formats()
parser = argparse.ArgumentParser()
parser.add_argument("-f", "--format", choices=formats, default="json")
ex_parsers = ExtraArgumentsParsers(parser, "--format")
for f in formats:
if f == "markdown": # xxx:
continue
m = import_module(f"dictknife.loading.{f}")
ex_parser = ex_parsers.add_parser(f)
setup = getattr(m, "setup_parser", None)
if setup is None:
print(f"{m.__name__} doesn't have setup_parser() function",
file=sys.stderr)
continue
setup(ex_parser)
args, rest = parser.parse_known_args()
extra, _ = ex_parsers.parse_args(args.format, rest)
print(args, extra)
L = [
{
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--driver",
default="kamidana.driver:Driver",
help="default: kamidana.driver:Driver",
)
parser.add_argument(
"--loader",
default="kamidana.loader:TemplateLoader",
help="default: kamidana.loader:TemplateLoader",
)
parser.add_argument("-d",
"--data",
action="append",
help="support yaml, json, toml",
default=[])
parser.add_argument("--logging",
choices=list(logging._nameToLevel.keys()),
default="INFO")
parser.add_argument("-a", "--additionals", action="append", default=[])
parser.add_argument("-e", "--extension", action="append", default=[])
parser.add_argument("-i",
"--input-format",
default=None,
choices=get_formats())
parser.add_argument("-o", "--output-format", default="raw")
parser.add_argument(
"--dump-context",
action="store_true",
help="dumping loading data (used by jinja2 template)",
)
parser.add_argument(
"--list-info",
action="store_true",
help=
"listting information (for available extensions and additional modules)",
)
parser.add_argument("template", nargs="?")
parser.add_argument("--debug", action="store_true")
parser.add_argument("--quiet", action="store_true")
parser.add_argument("--dst", default=None)
args = parser.parse_args()
logging.basicConfig(level=getattr(logging, args.logging))
with error_handler(debug=args.debug, quiet=args.quiet):
loader_cls = import_symbol(args.loader, ns="kamidana.loader", cwd=True)
extensions = [("jinja2.ext.{}".format(ext) if "." not in ext else ext)
for ext in args.extension]
loader = loader_cls(args.data,
args.additionals,
extensions,
format=args.input_format)
if args.template is None and not (args.dump_context or args.list_info):
logger.info("template is not passed, running as --dump-context")
args.dump_context = True
if args.dump_context:
driver_cls = import_symbol("ContextDumpDriver",
ns="kamidana.driver",
cwd=True)
elif args.list_info:
from kamidana import listinfo
output_format = args.output_format
if output_format == "raw":
output_format = "json"
print(
"\x1b[1mextensions are used by `-e`, additional modules are used by `-a`.\x1b[0m",
file=sys.stderr,
)
dumpfile(listinfo.listinfo(), format=output_format)
return print("")
else:
driver_cls = import_symbol(args.driver,
ns="kamidana.driver",
cwd=True)
driver = driver_cls(loader, format=args.output_format)
driver.run(args.template, args.dst)
