def run(*, src: str, savedir: str, dry_run: bool = False, sort_keys: bool = False) -> None: resolver = get_resolver(src) # xxx: sort_keys for ambitious output (for 3.6 only?) # xxx: sort_keys=True, TypeError is occured, compare between str and int # xxx: transform set by dump_options? m = Migration( resolver, dump_options={"sort_keys": sort_keys}, transform=partial(transform, sort_keys=sort_keys), ) with m.migrate(dry_run=dry_run, keep=True, savedir=savedir) as u: scope = Scope({ "consumes": ["application/json"], "produces": ["application/json"] }) callbacks = [] logger.debug("migrate mainfile file=%s", u.name) migrate_for_mainfile(u, scope=scope) for resolver in u.resolvers: uu = u.new_child(resolver) logger.debug("migrate subfile file=%s", uu.name) migrate_for_subfile(uu, scope=scope, callbacks=callbacks) # callback logger.debug("callbacks callbacks=%s", len(callbacks)) for resolver in u.resolvers: uu = u.new_child(resolver) for cb in callbacks: cb(uu)
def get_loader(filename: str) -> Loader: store = _yaml.NodeStore() yaml_loader_factory = _yaml.YAMLLoaderFactory(_yaml.YAMLLoader, store=store) resolver = jsonknife.get_resolver( filename, loader=_DictknifeLoaderAdapter(yaml_loader_factory)) return Loader(resolver, store=store)
def run(*, filename): def onload(d, resolver, w=DictWalker(["$include"])): for _, sd, in w.walk(d): subresolver, jsref = resolver.resolve(sd.pop("$include")) sd.update(subresolver.access_by_json_pointer(jsref)) resolver = get_resolver(filename, onload=onload) loading.dumpfile(resolver.doc)
def provide(): resolver = get_resolver(src) visitor = create_visitor() ctx = Context(resolver, emit=q.put) try: visitor.visit(ctx, resolver.doc) finally: q.put(None)
def run(*, src: str) -> None: logging.basicConfig(level=logging.DEBUG) resolver = get_resolver(src) with Migration(resolver).migrate(dry_run=True) as u: for k, item in u.iterate_items(): if k == "definitions/person": ref = "#/definitions/person/properties/value" u.update(item.resolver, ref, {"type": "integer"}) if k == "definitions/name": ref = "#/definitions/name/description" u.update(item.resolver, ref, "name of something")
def run(*, src: str) -> None: logging.basicConfig(level=logging.DEBUG) resolver = get_resolver(src) with Migration(resolver).migrate(keep=True) as u: for k, item in u.iterate_items(): if k == "definitions/person": ref = "#/definitions/person/properties/value" u.update(item.resolver, ref, {"type": "integer"}) if k == "definitions/name": ref = "#/definitions/name/description" u.update(item.resolver, ref, "name of something")
def run(*, src: str, savedir: str, log: str, dry_run: bool = False) -> None: logging.basicConfig(level=getattr(logging, log)) resolver = get_resolver(src) # xxx: sort_keys for ambitious output (for 3.6 only?) # xxx: sort_keys=True, TypeError is occured, compare between str and int # xxx: transform set by dump_options? m = Migration(resolver, dump_options={"sort_keys": False}, transform=transform) with m.migrate(dry_run=dry_run, keep=True, savedir=savedir) as u: scope = Scope() migrate_for_mainfile(u, scope=scope) migrate_for_subfile(u, scope=scope)
def run(*, src: str) -> None: logging.basicConfig(level=logging.DEBUG) resolver = get_resolver(src) with Migration(resolver).migrate(dry_run=True) as m: item_map = m.item_map for k, item in list(item_map.items()): if k == "definitions/person": ref = "#/definitions/person/properties/value" m.update(item.resolver, ref, {"type": "integer"}) if k == "definitions/name": ref = "#/definitions/name/description" m.update(item.resolver, ref, "name of something")
def run(*, src: str) -> None: resolver = get_resolver(src) with Migration(resolver).migrate_dryrun_and_diff() as m: item_map = m.item_map for k, item in list(item_map.items()): if k == "definitions/person": item.data["properties"] = ChainMap(make_dict(), item.data["properties"]) item.data["properties"]["value"] = {"type": "integer"} if k == "definitions/name": item.data = ChainMap(make_dict(), item.data) item.resolver.assign_by_json_pointer(item.localref, item.data) item.data["description"] = "name of something"
def run(*, src: str, savedir: str, log: str, dry_run: bool = False) -> None: logging.basicConfig(level=getattr(logging, log)) resolver = get_resolver(src) # xxx: sort_keys for ambitious output (for 3.6 only?) # xxx: sort_keys=True, TypeError is occured, compare between str and int # xxx: transform set by dump_options? m = Migration(resolver, dump_options={"sort_keys": False}, transform=transform) with m.migrate(dry_run=dry_run, keep=True, savedir=savedir) as u: scope = Scope() migrate_for_mainfile(u, scope=scope) migrate_for_subfile(u, scope=scope)
def run(*, src: str) -> None: resolver = get_resolver(src) with Migration(resolver).migrate_dryrun_and_diff() as m: item_map = m.item_map for k, item in list(item_map.items()): if k == "definitions/person": item.data["properties"] = ChainMap(make_dict(), item.data["properties"]) item.data["properties"]["value"] = {"type": "integer"} if k == "definitions/name": item.data = ChainMap(make_dict(), item.data) item.resolver.assign_by_json_pointer(item.localref, item.data) item.data["description"] = "name of something"
def run(*, src: str, savedir: str, log: str, dry_run: bool = False) -> None: logging.basicConfig(level=getattr(logging, log)) resolver = get_resolver(src) # xxx: sort_keys for ambitious output (for 3.6 only?) with Migration(resolver, dump_options={"sort_keys": True}).migrate( dry_run=dry_run, keep=True, savedir=savedir ) as u: for k, item in u.iterate_items(): if k == "definitions/person": ref = "#/definitions/person/properties/value" u.update(ref, {"type": "integer"}, resolver=item.resolver) if k == "definitions/name": ref = "#/definitions/name/description" u.update(ref, "name of something", resolver=item.resolver)
def main(): filename = sys.argv[1] yaml_loader_factory = LoaderFactory(Loader) resolver = get_resolver(filename, loader=_Adapter(yaml_loader_factory)) scaner = Scaner(resolver, store=yaml_loader_factory.store) doc = scaner.scan() print("----------------------------------------") subprocess.run(["cat", "-n", filename]) # from dictknife import loading # loading.dumpfile(doc) if scaner.errors: print("?", len(scaner.errors)) for err in scaner.errors: # type: ReferenceError print(err.describe())
def main(): filename = sys.argv[1] yaml_loader_factory = YAMLLoaderFactory(YAMLLoader) resolver = get_resolver(filename, loader=_Adapter(yaml_loader_factory)) scanner = DataScanner(resolver) doc = scanner.scan() print("----------------------------------------") subprocess.run(["cat", "-n", filename]) # from dictknife import loading # loading.dumpfile(doc) if scanner.errors: describer = Describer(yaml_loader_factory.store) print("?", len(scanner.errors)) for err in scanner.errors: print(describer.describe(err))
def main(): filename = sys.argv[1] yaml_loader_factory = LoaderFactory(Loader) resolver = get_resolver(filename, loader=_Adapter(yaml_loader_factory)) scaner = Scaner(resolver, store=yaml_loader_factory.store) doc = scaner.scan() # loading.dumpfile(doc) # with $ref if scaner.errors: # status := ERROR | WARNING | NOTE # <status>, <filename>, <start>, <end>, <msg> print("?", len(scaner.errors)) for err in scaner.errors: # type: ReferenceError print(err.describe()) print("----------------------------------------") subprocess.run(["cat", "-n", filename])
def main(): filename = sys.argv[1] yaml_loader_factory = LoaderFactory(Loader) resolver = get_resolver(filename, loader=_Adapter(yaml_loader_factory)) doc = resolver.doc expander = Expander(resolver) try: doc = expander.expand() loading.dumpfile(doc) # with $ref except MarkedYAMLError as e: padding = "" mark = e.context_mark or e.problem_mark filename = mark.name for r in resolver.path_list(filename): padding += " " print(padding, os.path.relpath(r.filename)) padding += " " print(padding, "problem", e.problem, "@", e.problem_mark) print(padding, "context", e.context, "@", e.context_mark) print("") node_cache = yaml_loader_factory.store.node_cache if expander.errors: print("?", len(expander.errors)) for path, e, sd in expander.errors: for knode, vnode in node_cache[id(sd)].value: print("!", repr(e), knode.value, path[-1]) if knode.value == path[-1]: print( "!!", knode.start_mark, knode.end_mark, "x", vnode.start_mark, vnode.end_mark, ) print("----------------------------------------") subprocess.run(["cat", "-n", filename])
def main(): filename = sys.argv[1] yaml_loader_factory = LoaderFactory(Loader) resolver = get_resolver(filename, loader=_Adapter(yaml_loader_factory)) doc = resolver.doc expander = Expander(resolver) try: doc = expander.expand() loading.dumpfile(doc) # with $ref except MarkedYAMLError as e: padding = "" mark = e.context_mark or e.problem_mark filename = mark.name for r in resolver.path_list(filename): padding += " " print(padding, os.path.relpath(r.filename)) padding += " " print(padding, "problem", e.problem, "@", e.problem_mark) print(padding, "context", e.context, "@", e.context_mark) print("") store = yaml_loader_factory.store if expander.errors: print("?", len(expander.errors)) for err in expander.errors: # type: ReferenceError map_node = err.lookup_node(store) knode, vnode = err.lookup_kvpair(map_node) print( "!!", knode.start_mark, knode.end_mark, "x", vnode.start_mark, vnode.end_mark, ) print("----------------------------------------") subprocess.run(["cat", "-n", filename])
def main(): filename = sys.argv[1] resolver = get_resolver(filename) try: expander = Expander(resolver) doc = expander.expand() loading.dumpfile(doc) except MarkedYAMLError as e: padding = "" mark = e.context_mark or e.problem_mark filename = mark.name for r in resolver.path_list(filename): padding += " " print(padding, os.path.relpath(r.filename)) padding += " " print(padding, "problem", e.problem, "@", e.problem_mark) print(padding, "context", e.context, "@", e.context_mark) print("") print("----------------------------------------") subprocess.run(["cat", "-n", filename])
def run(*, src: str) -> None: resolver = get_resolver(src) accessor = CachedItemAccessor(resolver) item_map = make_dict() scanner = Scanner(accessor, item_map, strict=True) scanner.scan(resolver.doc) resolvers = set() for k, item in list(item_map.items()): if k == "definitions/person": item.data["properties"] = ChainMap(make_dict(), item.data["properties"]) item.data["properties"]["value"] = {"type": "integer"} if k == "definitions/name": item.data = ChainMap(make_dict(), item.data) item.resolver.assign_by_json_pointer(item.localref, item.data) item.data["description"] = "name of something" resolvers.add(item.resolver) for r in resolvers: print(os.path.relpath(r.name, start=os.getcwd())) for line in diff(before_data(r.doc), after_data(r.doc)): print(line)
def run(*, src: str) -> None: resolver = get_resolver(src) accessor = CachedItemAccessor(resolver) item_map = make_dict() scanner = Scanner(accessor, item_map, strict=True) scanner.scan(resolver.doc) resolvers = set() for k, item in list(item_map.items()): if k == "definitions/person": item.data["properties"] = ChainMap(make_dict(), item.data["properties"]) item.data["properties"]["value"] = {"type": "integer"} if k == "definitions/name": item.data = ChainMap(make_dict(), item.data) item.resolver.assign_by_json_pointer(item.localref, item.data) item.data["description"] = "name of something" resolvers.add(item.resolver) for r in resolvers: print(os.path.relpath(r.name, start=os.getcwd())) for line in diff(before_data(r.doc), after_data(r.doc)): print(line)
def main(): filename = sys.argv[1] yaml_loader_factory = LoaderFactory(Loader) resolver = get_resolver(filename, loader=_Adapter(yaml_loader_factory)) doc = resolver.doc try: expander = Expander(resolver) doc = expander.expand() loading.dumpfile(doc) # with $ref except MarkedYAMLError as e: padding = "" mark = e.context_mark or e.problem_mark filename = mark.name for r in resolver.path_list(filename): padding += " " print(padding, os.path.relpath(r.filename)) padding += " " print(padding, "problem", e.problem, "@", e.problem_mark) print(padding, "context", e.context, "@", e.context_mark) print("") print("----------------------------------------") subprocess.run(["cat", "-n", filename]) node_cache = yaml_loader_factory.store.node_cache sd = doc["components"]["schemas"]["a"] if hasattr(sd, "maps"): sd = sd.maps[-1] # find original (in ChainMap) node = node_cache[id(sd)] print("@", node.start_mark) print("@", node.end_mark)
def run(src: str) -> None: resolver = get_resolver(src) def gen(*, path): def on_schema(d, *, path): for k, prop in d.get("properties", {}).items(): if not hasattr(prop, "get"): # print("hmm") continue path.append(k) if "$ref" in prop: k = prop["$ref"].rsplit("/", 1)[-1] prop = resolver.access_by_json_pointer(prop["$ref"]) # type: str?, object? yield from on_schema(prop, path=path) path.pop() yield ("/".join(path), d) yield from on_schema(resolver.doc, path=path) for name, node in gen(path=["Top"]): print(name, node.get("type")) print("*ok*")
def select( *, src: str, dst: str, refs, unwrap, wrap, input_format: str, output_format: str, format: str, ): from dictknife.jsonknife import Expander from dictknife.jsonknife.accessor import assign_by_json_pointer from dictknife.jsonknife import get_resolver input_format = input_format or format resolver = get_resolver(src) expander = Expander(resolver) if unwrap and not refs: refs = [] refs.append(unwrap) if not refs: d = expander.expand() else: d = make_dict() for ref in refs: ref_wrap = wrap if "@" in ref: ref, ref_wrap = ref.split("@", 1) extracted = expander.expand_subpart(expander.access(ref)) if ref_wrap: assign_by_json_pointer(d, ref_wrap, extracted) else: d = deepmerge(d, extracted) loading.dumpfile(d, dst, format=output_format or format)
def get_selector(filename: str, *, r=None) -> Selector: return Selector(get_resolver(filename), wrap=True, r=r)
from dictknife import loading from dictknife.jsonknife import get_resolver from dictknife.jsonknife import Bundler from dictknife import DictWalker import logging logging.basicConfig(level=logging.DEBUG) def build_subset(resolver, ref): subset = {} ob = resolver.access_by_json_pointer(ref) resolver.assign_by_json_pointer(ref, ob, doc=subset) for path, sd in DictWalker(["$ref"]).walk(ob): # xxx: if sd["$ref"].startswith("#/"): resolver.assign(path[:-1], sd, doc=subset) return subset filename = "./src/person.json" r = get_resolver(filename) subset = build_subset(r, "/definitions/person") b = Bundler(r) d = b.bundle(subset) loading.dumpfile(d)
from dictknife import loading from dictknife.jsonknife import get_resolver from dictknife.jsonknife import Bundler filename = "./src/main.json" r = get_resolver(filename) r.doc = { "definitions": { "person": r.access_by_json_pointer("/definitions/person"), } } b = Bundler(r) d = b.bundle() loading.dumpfile(d)