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 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)
