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)