def copytree(self, startnode=None): if startnode is None: startnode = self.__root walker = CopyWalker(startnode) walker.walk() class Object: pass coll = Object() coll.__class__ = Collection coll.__root = walker.get_new_root() coll.__node_map, coll.__id_map, coll.__ref_map = walker.get_new_info() return coll
def run() -> Module: r = get_resolver() m = Module(indent="\t") classes = [Person, Person2] for item in walk(classes): m.stmt(f"type {goname(item.cls.__name__)} struct {{") with m.scope(): for name, typeinfo, _metadata in item.fields: metadata = t.cast(Metadata, _metadata) if metadata.get("default") == MISSING: metadata.pop("default") try: gotype = r.resolve_gotype( typeinfo.normalized) # todo: pointer except KeyError: gotype = goname(typeinfo.normalized.__name__) if metadata.get("pointer", False): gotype = f"*{gotype}" if metadata.get("inline", False): m.append(gotype) else: m.append(f"{goname(name)} {gotype}") if metadata: m.stmt(f" // {metadata}") else: m.stmt("") m.stmt("}") m.sep() return m
def main(): # (define foo 4) foo = lsast.Name('foo') ass = lsast.Define(foo, lsast.Const(4)) # a1 = (+ 1 2 3) a1 = lsast.Add([lsast.Const(1), lsast.Const(2), lsast.Const(3)]) # a2 = (* 7 a1) a2 = lsast.Mul([lsast.Const(7), a1]) # a3 = (/ 42 a2) a3 = lsast.Div([lsast.Const(42), a2]) # a4 = (- foo a3) a4 = lsast.Sub([foo, a3]) sexp = lsast.Begin([ass, a4]) visitor = CodeGenLLVM.CodeGenLLVM() walker.walk(sexp, visitor, None, 1)
def emit(classes: t.List[t.Type[t.Any]], *, name: str = "main") -> Module: m = gofile(name) r = get_resolver(m) for item in walk(classes): if item.is_union: emit_union(m, item, resolver=r) m.sep() else: emit_struct(m, item, resolver=r) m.sep() if item.fields: emit_unmarshalJSON(m, item, resolver=r) m.sep() with m.func("main"): pass return m
def run() -> Module: r = get_resolver() m = gofile("main") classes = [Person, Person2] for item in walk(classes): gopackage = get_gopackage(item.cls) if gopackage is not None: continue m.stmt(f"type {goname(item.cls.__name__)} struct {{") with m.scope(): for name, typeinfo, _metadata in item.fields: metadata = t.cast(Metadata, _metadata) if metadata.get("default") == MISSING: metadata.pop("default") typ = typeinfo.raw if metadata.get("pointer", False): typ = t.Optional[typ] gotype: str = r.resolve_gotype(typ) gopackage = get_gopackage( typeinfo.normalized) # todo: support composite if gopackage is not None: gotype = f"{m.import_(gopackage)}.{gotype}" if metadata.get("inline", False): m.append(gotype) else: m.append(f"{goname(name)} {gotype}") if metadata: m.stmt(f" // {metadata}") else: m.stmt("") m.stmt("}") m.sep() return m
pickle.dump(u_graph, open(u_graph_path, 'bw')) else: u_graph = pickle.load(open(u_graph_path, 'br')) if not os.path.exists(i_graph_path): i_graph = getSimiGraph(df, Type='item', smplRate=1) pickle.dump(i_graph, open(i_graph_path, 'bw')) else: i_graph = pickle.load(open(i_graph_path, 'br')) # get walk u_walk_path = config['cache_path'] + config['name'] + '_user_w.pkl' i_walk_path = config['cache_path'] + config['name'] + '_item_w.pkl' if not os.path.exists(u_walk_path): u_walk = walk(u_graph, ) pickle.dump(u_walk, open(u_walk_path, 'bw')) else: u_walk = pickle.load(open(u_walk_path, 'br')) if not os.path.exists(i_walk_path): i_walk = walk(i_graph) pickle.dump(i_walk, open(i_walk_path, 'bw')) else: i_walk = pickle.load(open(i_walk_path, 'br')) embed = Embeder() if os.path.exists(config['cache_path'] + config['name'] + '_item_embed.pkl2'): i_embed = pickle.load( open(config['cache_path'] + config['name'] + '_item_embed.pkl2', 'br'))
def emit(classes: t.List[t.Type[t.Any]]) -> Module: m = gofile("main") r = get_resolver(m) for item in walk(classes): this = m.symbol(f"{item.type_.__name__[0].lower()}") this_type = f"{r.resolve_gotype(item.type_)}" this_type_pointer = f"*{this_type}" # func (ob *Ob) UnmarshalJSON(b []byte) error { b = m.symbol("b") m.stmt( f"func ({this} {this_type_pointer}) UnmarshalJSON({b} []byte) error {{" ) with m.scope(): # var err *maperr.Error err = m.symbol("err") maperr_pkg = m.import_("github.com/podhmo/maperr") m.stmt(f"var {err} *{maperr_pkg}.Error") m.sep() # var inner struct { # ... # } m.stmt("// loading internal data") inner = m.symbol("inner") m.stmt(f"var {inner} struct {{") with m.scope(): for name, typeinfo, metadata in item.fields: if name.startswith("_"): continue # xxx: gotype: str = r.resolve_gotype(typeinfo.raw) m.append(f'{goname(name)} *{gotype} `json:"{name}"`') m.stmt("// required" if metadata["required"] else "") m.stmt("}") # if rawErr := json.Unmarshal(b, &inner); rawErr != nil { # ... # } json_pkg = m.import_("encoding/json") raw_err = m.symbol("rawErr") with m.if_( f"{raw_err} := {json_pkg}.Unmarshal(b, &{inner}); {raw_err} != nil" ): m.return_(err.addSummary(raw_err.Error())) m.sep() # if <field> != nil { # ob.<field> = *<field> # } else { # m.add(<field>, "required") # } m.stmt("// binding field value and required check") for name, typeinfo, metadata in item.fields: field = m.symbol(goname(name)) with m.if_(f"{inner}.{field} != nil"): m.stmt(f"{this}.{field} = *{inner}.{field}") if metadata["required"]: with m.else_(): m.stmt(f'{err} = err.Add("{name}", "required")') m.sep() # return err.Untyped() m.return_(err.Untyped()) m.stmt("}") return m
from __future__ import annotations from prestring.text import Module from prestring.go import goname from egoist.go.resolver import get_resolver from walker import walk class Person: name: str age: int info: Info class Info: memo: str r = get_resolver() m = Module(indent="\t") for item in walk([Person]): m.stmt(f"type {goname(item.cls.__name__)} struct {{") with m.scope(): for name, typeinfo, metadata in item.fields: gotype = r.resolve_gotype(typeinfo.normalized) # todo: pointer m.stmt(f"{goname(name)} {gotype}") m.stmt("}") print(m)
in1_rel_relatefile = os.path.join(in1, rel_path, relatefile) out_rel_relatefile = os.path.join(out, rel_path, relatefile) if os.path.exists(in1_rel_relatefile): copyfile(in1_rel_relatefile, out_rel_relatefile, rel_path) print("relate {0}".format(os.path.join(rel_path, relatefile))) if node_name.endswith(".plist"): relatefile = node_name.replace(".plist",".png") in1_rel_relatefile = os.path.join(in1, rel_path, relatefile) out_rel_relatefile = os.path.join(out, rel_path, relatefile) if os.path.exists(in1_rel_relatefile): copyfile(in1_rel_relatefile, out_rel_relatefile, rel_path) print("relate {0}".format(os.path.join(rel_path, relatefile))) else: copyfile(in1_rel_filename, out_rel_filename, rel_path) print("add {0}".format(os.path.join(rel_path, node_name))) def node_filter(root_path, rel_path, node_name, node_type): if not '.svn' in node_name and not '.idea' in node_name: node_process(root_path, rel_path, node_name, node_type) if __name__ == "__main__": in1 = "dev" in2 = "base" out = "out" print in1,in2,out if os.path.exists(out): shutil.rmtree(out) os.makedirs(out) walker.walk(in1, "", node_filter)