Exemplo n.º 1
0
def emit(result: Result, *, m: t.Optional[Module] = None) -> Module:
    m = m or Module()
    m.toplevel = m.submodule()
    g = m.toplevel.import_("graphql", as_="g")
    m.sep()

    mapping = {
        str: g.GraphQLString,
        int: g.GraphQLInt,
        bool: g.GraphQLBool,
    }

    name_map = get_name_map(result, name="Person")
    for info in result.history:
        if not isinstance(info, Object):
            continue
        name = name_map["/".join(info.path)]
        m.stmt("{} = {}(", name, g.GraphQLObjectType)
        with m.scope():
            m.stmt("{!r},", name)
            m.stmt("lambda: {")
            with m.scope():
                for fieldname, field in info.props.items():
                    m.stmt(
                        "{!r}: {},",
                        fieldname,
                        g.GraphQLField(
                            to_graphql_type(field, mapping=mapping, g=g)),
                    )
            m.stmt("}")
        m.stmt(")")
    return m
Exemplo n.º 2
0
def argspec_to_schema(spec: inspect.FullArgSpec,
                      classname: str,
                      *,
                      m: t.Optional[Module] = None) -> str:
    if m is None:
        m = Module()
        m.from_("pydantic").import_("BaseModel")

    classified = _classify_args(spec)

    with m.class_(classname, "BaseModel"):
        fields = [(name, v) for name, v in spec.annotations.items()
                  if name != "return"]
        if len(fields) == 0:
            m.stmt("pass")
        for name, typ in fields:
            kind = classified[name]
            if kind == "args":
                continue
            elif kind == "args_defaults":
                continue
            elif kind == "kw":
                m.stmt("{}: {}", name, _resolve_type(typ))
            elif kind == "kw_defaults":
                m.stmt("{}: {}  = {}", name, _resolve_type(typ),
                       spec.kwonlydefaults[name])
            else:
                raise ValueError(f"invalid kind. name={name}, kind={kind}")
    return m
Exemplo n.º 3
0
def gen(target: ModuleType, *, m=None):
    m = m or Module()

    m.import_("typing as t")
    m.from_("pydantic", "BaseModel")
    m.from_("fastapi", "APIRouter", "Depends")
    m.from_("monogusa.web", "runtime")
    m.import_(target.__name__)
    m.stmt("router = APIRouter()")

    m.sep()

    # TODO: collect functions and use them.
    spec = fnspec.fnspec(commands.hello)
    co = fnspec.spec_to_schema_code(spec, name=pascalcase(spec.name))
    co.emit(m=m)

    m.stmt('@router.post ( "/{}", response_model=runtime.CommandOutput )',
           spec.name)
    with m.def_(
            spec.name,
            f"input: {co.name}",
            "writer: commands.Writer =  Depends(commands.writer)",  # deps
            return_type="t.Dict[str, t.Any]",
    ):
        with m.with_("runtime.handle() as s"):
            m.stmt("{}.{}(writer, **input.dict())", target.__name__, spec.name)
            m.stmt("return s.dict()")

    return m
Exemplo n.º 4
0
def argspec_to_schema(spec: FuncSpec,
                      *,
                      name: str,
                      m: t.Optional[Module] = None) -> str:
    if m is None:
        m = Module()
        m.from_("pydantic").import_("BaseModel")

    with m.class_(name, "BaseModel"):
        if len(spec.arguments) == 0:
            m.stmt("pass")

        for name, typ in spec.arguments:
            kind = spec.kind_of(name)
            if kind == "args":
                continue
            elif kind == "args_defaults":
                continue
            elif kind == "kw":
                m.stmt("{}: {}", name, spec.type_str_of(typ))
            elif kind == "kw_defaults":
                m.stmt(
                    "{}: {}  = {}",
                    name,
                    spec.type_str_of(typ),
                    spec.kwonlydefaults[name],
                )
            else:
                raise ValueError(f"invalid kind. name={name}, kind={kind}")
    return m
Exemplo n.º 5
0
    def parse_args(self, *args, **kwargs):
        self.history.append({
            "name": "parse_args",
            "args": args,
            "kwargs": kwargs
        })
        from prestring.python import Module, LazyArgumentsAndKeywords

        def _make_args(history, default=""):
            name = history["name"]
            if name == "__init__":
                name = default
            kwargs = {k: repr(v) for k, v in history["kwargs"].items()}
            args = [repr(v) for v in history["args"]]
            return f"{name}({LazyArgumentsAndKeywords(args, kwargs)})"

        m = Module()
        with m.def_("Main"):
            m.import_("argparse")
            m.stmt(
                f"parser = argparse.ArgumentParser{_make_args(self.history[0])}"
            )
            for x in self.history[1:-1]:
                m.stmt(f"parser.{_make_args(x)}")
            m.stmt(f"args = parser.{_make_args(self.history[-1])}")
            m.stmt("main(**vars(args))")

        with m.if_("__name__ == '__main__'"):
            m.stmt("Main()")

        print(m)
        sys.exit(0)
Exemplo n.º 6
0
    def parse_args(self, *args, **kwargs):
        self.history.append({"name": "parse_args", "args": args, "kwargs": kwargs})
        from prestring.python import Module, LazyArgumentsAndKeywords

        def _make_call_stmt(history, default=""):
            name = history["name"]
            if name == "__init__":
                name = default
            kwargs = {k: repr(v) for k, v in history["kwargs"].items()}
            args = [repr(v) for v in history["args"]]
            return f"{name}({LazyArgumentsAndKeywords(args, kwargs)})"

        m = Module()
        m.sep()
        with m.def_("main"):
            m.import_("argparse")
            m.stmt(f"parser = argparse.ArgumentParser{_make_call_stmt(self.history[0])}")
            m.stmt("parser.print_usage = parser.print_help")
            for x in self.history[1:-1]:
                m.stmt(f"parser.{_make_call_stmt(x)}")
            m.stmt(f"args = parser.{_make_call_stmt(self.history[-1])}")
            m.stmt(f"{self.fn.__name__}(**vars(args))")

        with m.if_("__name__ == '__main__'"):
            m.stmt("main()")

        with open(inspect.getsourcefile(self.fn)) as rf:
            source = rf.read()
        rx = re.compile("(?:@([\S]+\.)?as_command.*|^.*import ascommand.*)\n", re.MULTILINE)
        exposed = rx.sub("", "".join(source))
        print(exposed)
        print(m)
        sys.exit(0)
Exemplo n.º 7
0
def run(*, path: str, disable_docstring) -> None:
    d = loading.loadfile(path)
    m = Module()
    a = Accessor(d, m, disable_docstring=disable_docstring)

    m.import_("typing", as_="t")
    m.sep()
    m.stmt("AnyService = t.Any  # TODO")
    m.stmt("AnyResource = t.Any  # TODO")
    m.sep()
    for rname, resource in a.resources.items():
        with m.class_(titleize(rname), ""):

            with m.method("__init__", "resource: AnyResource"):
                m.stmt("self.internal = resource")

            m.stmt("# methods")
            for mname, method, params in a.iterate_methods(resource):
                with m.method(mname, params):
                    a.emit_docstring(method["description"])
                    m.stmt(
                        f"""# {method["httpMethod"]}: {method["flatPath"]}""")
                    m.stmt(f"""# id: {method["id"]}""")
                    m.stmt(f"return self.internal.{mname}({params})")

            m.stmt("# nested resources")
            for srname, subresource in a.iterate_nested_resources(resource):
                with m.method(srname):
                    m.stmt(f"return self.internal.{srname}({params})")

            # m.stmt("# nested resources")
            # for mname, subresource in resource.get("resources", {}).items():
            #     params = LParams()
            #     for is_positional, (pname, parameter) in itertools.zip_longest(subresource.get("parameterOrder", []), subresource.get("parameters", {}).items()):
            #         if is_positional:
            #             params.append(pname)  # TODO type:
            #         else:
            #             params[pname] = None  # TODO type:
            #     with m.method(mname, params):
            #         docstring(subresource["description"])
            #         m.stmt(f"""# id: {subresource["id"]}""")
            #         m.stmt(f"return self.{mname}({params})")

    with m.class_("Service"):
        with m.method("__init__", "service: AnyService"):
            m.stmt("self.internal = service")

        for rname in a.resources.keys():
            with m.method(rname, return_type=titleize(rname)):
                m.stmt(f"return {titleize(rname)}(self.internal.{rname}())")

    with m.def_("build", "*args", "**kwargs", return_type="Service"):
        m.stmt("# TODO: use the signature of googleapiclient.discovery.build")
        m.submodule().from_("googleapiclient.discovery", "build")
        m.stmt(
            f"return Service(build({a.name!r}, {a.version!r}, *args, **kwargs))"
        )

    print(m)
Exemplo n.º 8
0
def gen() -> Module:
    m = Module()
    with m.def_("foo", "x", "y", return_type="int"):
        m.stmt("pass")

    with m.def_("bar", "x", return_type="int"):
        m.stmt("pass")
    return m
Exemplo n.º 9
0
 def __init__(self, parent):
     self.scanned = set()
     self.parent = parent
     m = self.m = Module()
     with m.def_("includeme_swagger_router", "config"):
         self.fm = m.submodule()
         self.scanm = m.submodule()
     with m.def_("includeme", "config"):
         m.stmt("config.include(includeme_swagger_router)")
Exemplo n.º 10
0
def main():
    import inspect
    from prestring.python import Module
    from prestring.python.transform import transform_string

    m = Module()
    source = inspect.getsource(hello)
    m = transform_string(source, m=m)
    print(m)
Exemplo n.º 11
0
def emit(ctx: Context):
    from prestring.python import Module

    m = Module()
    for name, cls in ctx.types.items():
        with m.class_(name):
            # TODO: omit class inheritance
            for field_name, field_type in t.get_type_hints(cls).items():
                # TODO: to pytype
                m.stmt(f"{field_name}: {field_type.__name__}")
    return m
Exemplo n.º 12
0
def main(d: AnyDict, *, verbose: bool = False) -> None:
    logging.basicConfig(level=logging.INFO)  # debug

    m = Module()
    import_area: Module = m.submodule()
    import_area.stmt("from __future__ import annotations")

    ctx = Context(import_area=import_area, verbose=verbose)
    scan(ctx, d=d)

    emitter = Emitter(m=m)
    print(emitter.emit(ctx))

    cc = ctx.cache_counter
    logger.info("cache hits=%s, most common=%s", sum(cc.values()),
                cc.most_common(3))
Exemplo n.º 13
0
    def __init_subclass__(cls):
        hints = t.get_type_hints(cls)
        m = Module()

        name = cls.__name__
        fields = [
            V(name=k, type_=v.__name__ if hasattr(v, "__name__") else v)
            for k, v in hints.items()
        ]
        _gen_init(m, name=name, fields=fields)
        _gen_repr(m, name=name, fields=fields)
        code = str(m)

        d = {}
        exec(code, d)
        cls.__init__ = d["__init__"]
        cls.__repr__ = d["__repr__"]
Exemplo n.º 14
0
def transform(node, *, m=None, is_whole=None):
    is_whole = is_whole or m is None
    if m is None:
        m = Module()
        m.g = m.submodule()

    if is_whole:
        m.g.from_("prestring.python", "Module")
        m.g.stmt("m = Module()  # noqa")

    t = Transformer(node, m=m)
    t.visit(node)

    if len(m.g.imported_set) > 0:
        m.g.stmt("m.sep()")
        m.g.sep()

    if is_whole:
        m.stmt("print(m)")
    return m
Exemplo n.º 15
0
def emit(filename: str, *, use_fullname: bool = False) -> None:
    from dictknife import loading
    from prestring.python import Module
    from detector import detect, Object, TypeInfo, ZERO, generate_annotations

    name_map = {}
    m = Module()
    m.toplevel = m.submodule()
    m.sep()

    def _pytype(info: TypeInfo,
                *,
                m=m,
                aliases: t.Dict[str, str] = {"typing": "t"}):
        if info is ZERO:
            module = aliases.get(t.__name__) or t.__name__
            return f"{module}.Any"

        if hasattr(info, "base"):
            module = aliases.get(info.base.__module__) or info.base.__module__
            m.toplevel.import_(info.base.__module__,
                               aliases.get(info.base.__module__))
            if info.base is t.Optional:
                return f"{module}.Optional[{_pytype(info.item)}]"
            elif info.base is t.List:
                return f"{module}.List[{_pytype(info.item)}]"
        elif hasattr(info, "type"):
            module = aliases.get(info.type.__module__) or info.type.__module__
            prefix = module + "."
            if module == "builtins":
                prefix = ""
            else:
                m.toplevel.import_(info.type.__module__,
                                   aliases.get(info.type.__module__))
            return prefix + info.type.__name__
        try:
            return name_map[id(info)]
        except KeyError:
            # FIXME: bug
            import sys

            print(f"something wrong: {info}", file=sys.stderr)
            return "UNKNOWN"

    d = loading.loadfile(filename)
    result = detect(d)
    annotations = generate_annotations(result,
                                       use_fullname=use_fullname,
                                       toplevel_name="toplevel")

    for info in result.history:
        if isinstance(info, Object):
            metadata = annotations["/".join(info.path)]
            name = metadata.get("after", metadata["before"])["name"]
            name_map[id(info)] = name

            m.stmt(f"# from: {'/'.join(info.path)}")
            with m.class_(name):
                for name, sub_info in info.props.items():
                    m.stmt("{}: {}", name, _pytype(sub_info))
    print(m)
Exemplo n.º 16
0
def main():
    from openapi_stream import main

    m = Module(import_unique=True)
    m.header_area = m.submodule()
    m.import_area = m.submodule()
    m.sep()

    g = Generator(m)
    toplevels: t.List[Event] = []

    stream: t.Iterable[Event] = main(create_visitor=ToplevelVisitor)

    def consume_stream(stream: t.Iterable[Event], *, is_delayed=False) -> t.List[Event]:
        delayed_stream: t.List[Event] = []
        for ev in stream:
            if ev.uid in g.name_manager:
                continue

            if names.roles.has_expanded in ev.roles:
                g.case_definitions_manager.add_definitions(
                    ev.get_annotated(names.annotations.expanded)["definitions"]
                )
            if names.roles.has_name in ev.roles:
                g.generate_class(ev)
                continue

            if not is_delayed:
                if names.roles.toplevel_properties in ev.roles:
                    toplevels.append(ev)  # xxx
                delayed_stream.append(ev)
                continue

            # xxx:
            if (
                ev.name in (names.types.object, names.types.array)
                or names.roles.combine_type in ev.roles
                or names.roles.child_of_xxx_of in ev.roles
                or names.roles.field_of_something in ev.roles
            ):
                uid_and_clsname_pairs = sorted(
                    g.name_manager.iterate_clssname_and_prefix_pairs(),
                    key=lambda pair: len(pair[0]),
                    reverse=True,
                )

                uid = ev.uid
                for parent_uid, (parent_clsname, prefix) in uid_and_clsname_pairs:
                    if uid.startswith(parent_uid):
                        classdef_sm = g._end_of_class_definition_conts[parent_uid]
                        fieldname = uid.replace(parent_uid, "").lstrip("/")
                        clsname = f"_{g.helper.classname(ev, name=fieldname)}"

                        classdef_sm.stmt(
                            f"# anonymous definition for {fieldname!r} (TODO: nodename)"
                        )
                        g.generate_class(
                            ev,
                            clsname=clsname,
                            m=classdef_sm,
                            prefix=f"{prefix}{parent_clsname}.",
                        )

                        # ok: properties
                        # ok:  oneOf, anyof, allof
                        # todo: additionalProperties, patternProperties
                        # assert "/" not in fieldname
                        name = fieldname
                        g._gen_visitor_property(ev, name=name, uid=uid, m=classdef_sm)
                        break
                else:
                    raise RuntimeError(f"unexpected type: {ev.name}")

        return delayed_stream

    delayed_stream = consume_stream(stream, is_delayed=False)

    for ev in toplevels:
        if ev.uid.endswith("#/"):
            g.generate_class(ev, clsname="Toplevel")

    import os.path

    m.header_area.stmt(
        f"# generated from {os.path.relpath(ev.root_file, start=os.getcwd())}"
    )
    m.import_area.from_("dictknife.langhelpers", "reify")
    m.import_area.from_("openapi_stream", "runtime")
    m.import_area.from_("openapi_stream.context", "Context")

    delayed_stream = sorted(delayed_stream, key=lambda ev: len(ev.uid))
    delayed_stream = consume_stream(delayed_stream, is_delayed=True)

    if g.case_definitions_manager.has_definitions:
        data = {"definitions": g.case_definitions_manager.definitions}
        m.import_area.from_("openapi_stream", "runtime")
        g.emitter.emit_data(m, "_case = runtime.Case({})", data, nofmt=True)

    print(m)
Exemplo n.º 17
0
import inspect
from yaml.constructor import Constructor
from prestring.python import Module

m = Module()
m.from_("yaml.constructor", "Constructor")
m.sep()
with m.class_("WrappedConstructor", "Constructor"):
    with m.def_("wrap", "self", "path", "name", "node", "r"):
        with m.if_("r is None"):
            m.stmt("return r")
        m.stmt('# print("@", id(r), repr(r))')
        m.stmt("mem[id(r)] = node")
        m.stmt("return r")

    seen = set()
    for cls in Constructor.mro():
        for name, attr in cls.__dict__.items():
            if name in seen:
                continue
            seen.add(name)
            if name.startswith("construct_") and callable(attr):
                sigs = inspect.signature(attr)
                m.stmt("def {}{}:", name, sigs)
                with m.scope():
                    args = []
                    for v in sigs.parameters.values():
                        if v.name == "self":
                            continue
                        if v.default is inspect._empty:
                            args.append(str(v))
Exemplo n.º 18
0
from prestring.python import Module
import matplotlib.cm as cm

m = Module()  # noqa
m.from_('nbreversible', 'code')
m.import_('pandas as pd')
m.import_('numpy as np')
m.import_('seaborn as sns')
m.sep()

m.stmt('"# [jupyter][matplotlib][python] color mapの一覧をheatmapで"')
m.stmt('# %matplotlib inline')
with m.with_('code()'):
    m.stmt('xs = np.arange(1, 10)')
    m.stmt('ys = np.arange(1, 10).reshape(9, 1)')
    m.stmt('m = xs * ys')
    m.stmt('df = pd.DataFrame(m)')
    m.stmt('df')

for name in cm.cmap_d.keys():
    m.stmt(f'"## {name}"')
    m.sep()
    with m.with_("code()"):
        m.stmt(f"sns.heatmap(df, {name!r})")
    m.sep()

print(m)
 def __init__(self, m=None, im=None):
     self.m = m or Module(import_unique=True)
     self.im = im or self.m.submodule()
Exemplo n.º 20
0
 def emit(self, *, m: t.Optional[Module] = None) -> Module:
     m = m or Module()
     return self._emit(m, name=self.name)
Exemplo n.º 21
0
def gen_class_code(name: str, fields: t.List[V]) -> str:
    m = Module()
    with m.class_(name):
        _gen_init(m, name=name, fields=fields)
        _gen_repr(m, name=name, fields=fields)
    return str(m)
Exemplo n.º 22
0
 def __init__(self, *, m: t.Optional[Module] = None) -> None:
     self.m = m or Module()
Exemplo n.º 23
0
 def __init__(self, parent):
     self.parent = parent
     self.m = Module(import_unique=True)
     self.im = self.m.submodule()
     self.m.sep()
Exemplo n.º 24
0
def code(name):
    m = Module()
    m.stmt("{} = 1", name)