def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("src", nargs="?", default=None)
parser.add_argument("--package", default=None)
parser.add_argument("--position", default=None)
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),
)
data = loading.loadfile(args.src)
package = r.package(args.package or "main")
walk(data, package, r)
d = r.resolve_package_path(args.position, package)
r.emitter.emit_package(package, d=d)
def worker(
*,
manager: str,
handler: str,
kwargs: t.Dict[str, t.Any],
config: str,
config_options: t.Union[str, t.Dict[str, t.Any], None] = None) -> None:
from magicalimport import import_symbol
from minitask import _options
kwargs = _options.loads(kwargs)
options = _options.loads(config_options)
handler_callable = import_symbol(handler, cwd=True)
config_object = import_symbol(config, cwd=True)(**options)
manager_object = import_symbol(manager, cwd=True)(config_object)
handler_callable(manager_object, **kwargs)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--driver",
default="swagger_marshmallow_codegen.driver:Driver")
parser.add_argument(
"--logging",
default="INFO",
choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"])
parser.add_argument("--full", default=False, action="store_true")
parser.add_argument("file", default=None)
args = parser.parse_args()
driver_cls = args.driver
if ":" not in driver_cls:
driver_cls = "swagger_marshmallow_codegen.driver:{}".format(driver_cls)
if args.full:
options = {"targets": {"schema": True, "input": True, "output": True}}
else:
options = {"targets": {"schema": True}}
driver = import_symbol(driver_cls)(options)
# todo: option
logging.basicConfig(format="%(levelname)5s:%(name)36s:%(message)s",
level=logging._nameToLevel[args.logging])
if args.file is None:
driver.run(sys.stdin, sys.stdout)
else:
with open(args.file) as rf:
driver.run(rf, sys.stdout)
def capture(*, command, outfile, interval, display_function, extras, **kwargs):
from moduleknife.ticker import tick, setup
from moduleknife.display import RemoteDisplay
fn = import_symbol(display_function)
# factory object
if isinstance(fn, type):
if outfile is None:
output = sys.stderr
else:
output = open(outfile, "w")
import atexit
def message():
output.close()
print("write {} ...".format(outfile), file=sys.stderr)
atexit.register(message)
fn = RemoteDisplay(fn(output))
setup()
cancel = tick(fn, interval=interval) # noqa
return calling.call_file(command, extras)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("target",
help="the module or class to extract schemas from")
parser.add_argument("--format", default=None, choices=["json", "yaml"])
parser.add_argument(
"--walker",
choices=["noforeignkey", "foreignkey", "structural"],
default="structural",
)
parser.add_argument("--decision",
choices=["default", "useforeignkey"],
default="default")
parser.add_argument("--depth", default=None, type=int)
parser.add_argument("--out", default=None, help="output to file")
parser.add_argument(
"--layout",
choices=["swagger2.0", "jsonschema", "openapi3.0", "openapi2.0"],
default="swagger2.0",
)
parser.add_argument("--driver",
default="alchemyjsonschema.command.driver:Driver")
args = parser.parse_args()
driver_cls = import_symbol(args.driver, cwd=True)
driver = driver_cls(args.walker, args.decision, args.layout)
driver.run(args.target, args.out, format=args.format)
def json2swagger(
*,
files,
dst: str,
output_format: str,
name: str,
detector,
emitter,
annotate,
emit,
with_minimap: bool,
without_example: bool
):
from prestring import Module
from dictknife import DictWalker
if annotate is not None:
annotate = loading.loadfile(annotate)
else:
annotate = {}
ns = "dictknife.swaggerknife.json2swagger"
detector = import_symbol(detector, ns=ns)()
emitter = import_symbol(emitter, ns=ns)(annotate)
info = None
for src in files:
data = loading.loadfile(src)
info = detector.detect(data, name, info=info)
if emit == "info":
loading.dumpfile(info, filename=dst)
else:
m = Module(indent=" ")
m.stmt(name)
emitter.emit(info, m)
if with_minimap:
print("# minimap ###")
print("# *", end="")
print("\n# ".join(str(m).split("\n")))
if without_example:
for _, d in DictWalker(["example"]).walk(emitter.doc):
d.pop("example")
loading.dumpfile(emitter.doc, filename=dst, format=output_format)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--target", default="world")
parser.add_argument("--driver", default="{}:Driver".format(__name__))
args = parser.parse_args()
driver_class = magicalimport.import_symbol(args.driver)
driver = driver_class()
driver.run(args.target)
def call_file(fname, extras):
sys.argv = [fname]
sys.argv.extend(extras)
if ":" in fname:
return import_symbol(fname)()
elif os.path.exists(fname) and not os.path.isdir(fname):
return call_file_as_main_module(fname)
cmd_path = shutil.which(fname)
if cmd_path:
return call_command_as_main_module(fname, cmd_path)
def run(
filename: str,
*,
aggressive: bool = False,
is_member: t.Optional[t.Callable[[t.Type[T]], bool]] = None,
emit: t.Optional[EmitFunc] = None,
) -> None:
m = import_module(filename, cwd=True)
walker = get_walker(m, aggressive=aggressive)
emit = emit or import_symbol("metashape.outputs.raw:emit") # xxx:
logger.debug("collect members: %d", len(walker))
emit(walker, output=sys.stdout)
def main():
import logging
logging.basicConfig(level=logging.INFO)
import magicalimport
handler_main = magicalimport.import_symbol("./03handler_cli.py:main")
app = make_app(handler_main)
port = find_free_port()
httpd = make_server('', port, app)
logger.info("Serving on port %s...", port)
httpd.serve_forever()
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 perf(ll, n, m, name):
f = import_symbol(name)
elapsed = []
# print("before: ", ll[-1])
ans = None
for l in ll:
start = time.time()
ans = f(l, n, m)
end = time.time()
elapsed.append(end - start)
# print("after: ", ans)
print(name, np.average(elapsed))
def perf(ll, n, m, name):
f = import_symbol(name)
elapsed = []
# print("before: ", ll[-1])
ans = None
for l in ll:
start = time.time()
ans = f(l, n, m)
end = time.time()
elapsed.append(end - start)
# print("after: ", ans)
print(name, np.average(elapsed))
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 call_file(fname, extras):
sys.argv = [fname]
sys.argv.extend(extras)
if ":" in fname:
return import_symbol(fname, cwd=True)()
elif os.path.exists(fname) and not os.path.isdir(fname):
# for: python <file>
spec = spec_from_file_location("__main__", fname)
return SourceFileLoader("__main__", spec.origin).load_module()
cmd_path = shutil.which(fname)
if cmd_path:
return SourceFileLoader("__main__", cmd_path).load_module()
else:
raise RuntimeError("{} is not found".format(fname))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--port", default=None, type=int)
parser.add_argument("--logging",
choices=list(logging._nameToLevel.keys()),
default="DEBUG")
parser.add_argument("--callback", default=None)
parser.add_argument("--pretty", action="store_true")
parser.add_argument("--pdb", action="store_true")
args = parser.parse_args()
logging.basicConfig(level=args.logging)
callback = args.callback
if callback is not None:
callback = magicalimport.import_symbol(callback, cwd=True)
elif args.pdb:
callback = pdb_callback
run(port=args.port, callback=callback, pretty=args.pretty)
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 logging
logging.basicConfig(level=logging.INFO)
import magicalimport
handler_main = magicalimport.import_symbol("./05handler_cli.py:main")
app = make_app(handler_main)
port = find_free_port()
httpd = make_server('', port, app)
th = threading.Thread(target=httpd.serve_forever, daemon=True)
logger.info("Serving on port %s...", port)
th.start()
rows = [10, 20, 30, 40, 50]
for row in rows:
payload = row
response = requests.post(f"http://localhost:{port}", json=payload)
data = response.json()
logger.info("response status=%s, data=%s", response.status_code, data)
def main():
parser = argparse.ArgumentParser(add_help=False)
parser.add_argument("file")
parser.add_argument("--outfile", default=None)
parser.add_argument("--metadata",
choices=["time", "memory"],
default="time")
parser.add_argument("--browse", action="store_true")
parser.add_argument(
"--driver",
default="moduleknife.commands.modulegraph:Driver",
help="default: moduleknife.commands.modulegraph:Driver",
)
args, extras = parser.parse_known_args()
driver_cls = import_symbol(args.driver,
ns="moduleknife.commands.modulegraph")
metadata_handler = globals().get(args.metadata + "Handler", timeHandler)()
driver = driver_cls(args.outfile, metadata_handler, browse=args.browse)
with capture_with_signal_handle(driver.add, teardown=driver.finish):
driver.run(args.file, extras)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--driver",
default="pyramid_swagger_router.driver:Driver")
parser.add_argument(
"--logging",
default="INFO",
choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"])
parser.add_argument("src")
parser.add_argument("dst")
args = parser.parse_args()
# todo: option
logging.basicConfig(format="%(levelname)5s:%(name)36s:%(message)s",
level=logging._nameToLevel[args.logging])
driver_cls = args.driver
if ":" not in driver_cls:
driver_cls = "pyramid_swagger_router.driver:{}".format(driver_cls)
driver = import_symbol(driver_cls)()
with open(args.src) as rf:
driver.run(rf, args.dst)
def load_def_map(cls, type_map):
return {
pair: import_symbol(path, cwd=True)
for pair, path in type_map.items()
}
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)
import dataclasses
import logging
from dictknife import loading
from magicalimport import import_symbol
logging.basicConfig(level=logging.DEBUG)
target = import_symbol("./conf.py:toplevel", here=__file__)
d = dataclasses.asdict(target)
loading.dumpfile(d, format="yaml")
def test_resolve_type(typ, want):
callFUT = import_symbol("./12resolve.py:resolve_type")
got = callFUT(typ)
assert got == want
def transform(d):
for fn in functions:
if "." not in fn:
fn = "dictknife.transform:{}".format(fn)
d = import_symbol(fn)(d)
return d
def run(*, config: str):
c: Config = magicalimport.import_symbol(config, cwd=True)
print("db url is", c.app.db)
def test_resolve_type_info(typ, want):
callFUT = import_symbol("./08resolve.py:resolve_type_info")
got = callFUT(typ)
assert got == want
async def main() -> None:
app = magicalimport.import_symbol("01api.py:app", here=__file__)
async with TestClient(app) as client:
response = await client.get("/openapi.json")
loading.dumpfile(response.json())
import unittest
from magicalimport import import_symbol
# from: glob2
glob = import_symbol("./08walk.py:glob")
class TestPatterns(unittest.TestCase):
def test(self):
d = {
"dir1": {"a-file": "a1", "b-file": "b1"},
"dir22": {"a-file": "a22", "b-file": "b22"},
}
got = glob(d, "dir?/a-*")
want = [("dir1/a-file", "a1")]
self.assertListEqual(list(got), list(want))
def makedirs(d, *paths):
for path in paths:
path = path.split("/")
target = d
for k in path:
if k not in target:
target[k] = {}
target = target[k]
return d
def touch(d, *paths, content=None):
import fs
from magicalimport import import_symbol
# pip install fs magicalimport
create_fs = import_symbol("./02inmemory.py:create")
with create_fs("03copyfs") as my_fs:
# copy filesystem
from fs.copy import copy_fs # noqa
def on_copy(src_fs, src_name: str, dst_fs, dst_name: str) -> None:
import sys
print(f"copied {src_fs}:{src_name} -> {dst_name}", file=sys.stderr)
copy_fs(my_fs, fs.open_fs("./"), on_copy=on_copy)
from magicalimport import import_symbol
config = import_symbol("./config.py:config", here=__file__)
print(config)
