jaclang 0.0.2__tar.gz → 0.0.3__tar.gz

{jaclang-0.0.2 → jaclang-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.0.2
+Version: 0.0.3
 Summary: UNKNOWN
 Home-page: https://github.com/Jaseci-Labs/jaclang
 Author: Jason Mars

jaclang-0.0.3/jaclang/cli/impl/__init__.py

@@ -0,0 +1 @@
+"""For setuptools to find this dir."""

jaclang-0.0.3/jaclang/cli/impl/cli_impl.jac

@@ -0,0 +1,93 @@
+"""Implemenation for Jac's command line interface."""
+
+:o:Command:a:init(func: callable) {
+    <s>.func = func;
+    <s>.sig = func |> inspect.signature;
+}
+
+:o:Command:a:call(*args: list, **kwargs: dict) {
+    return (*args, **kwargs) |> <s>.func;
+}
+
+:o:CommandRegistry:a:init {
+    <s>.registry = {};
+    <s>.parser = (prog="CLI") |> argparse.ArgumentParser;
+    <s>.sub_parsers =
+        (title="commands", dest="command") |> <s>.parser.add_subparsers;
+}
+
+:o:CommandRegistry:a:register(func: callable) {
+    name = func.__name__;
+    cmd = func |> Command;
+    <s>.registry[name] = cmd;
+    cmd_parser = name |> <s>.sub_parsers.add_parser;
+    for param_name, param in |> cmd.sig.parameters.items {
+        if param_name == "args" {
+            ('args', nargs=argparse.REMAINDER)
+                |> cmd_parser.add_argument;
+        }
+        elif param.default is param.empty {
+            (f"-{param_name[:1]}", f"--{param_name}",
+            required=True, type=param.annotation|>eval)
+                |> cmd_parser.add_argument;
+        }
+        else {
+            (f"-{param_name[:1]}", f"--{param_name}",
+            default=param.default, type=param.annotation|>eval)
+                |> cmd_parser.add_argument;
+        }
+    }
+    return func;
+}
+
+:o:CommandRegistry:a:get(name: str) -> Command {
+    return name |> <s>.registry.get;
+}
+
+:o:CommandRegistry:a:items -> dict[str, Command] {
+    return |> <s>.registry.items;
+}
+
+
+:o:CommandShell:a:init (cmd_reg: CommandRegistry) {
+    <s>.cmd_reg = cmd_reg;
+    <s> |> cmd.Cmd.__init__;
+}
+
+:o:CommandShell:a:do_exit(arg: list) -> bool {
+    return True;
+}
+
+:o:CommandShell:a:default(line: str) {
+    try {
+        args = |> line.split |> <s>.cmd_reg.parser.parse_args |> vars;
+        command = args["command"] |> <s>.cmd_reg.get;
+        if command {
+            args.pop("command");
+            ret = **args |> command.call;
+            if ret {
+                ret |> print;
+            }
+        }
+    }
+    except Exception as e {
+        e |> print;
+    }
+}
+
+:a:start_cli {
+    parser = cmd_registry.parser;
+    args = |> parser.parse_args;
+    command = args.command |> cmd_registry.get;
+    if command {
+        args = args |> vars;
+        "command" |> args.pop;
+        ret = **args |> command.call;
+        if ret {
+            ret |> print;
+        }
+    }
+    else {
+        shell = |> CommandShell(cmd_registry).cmdloop;
+    }
+}

jaclang-0.0.3/jaclang/cli/impl/cmds_impl.jac

@@ -0,0 +1,26 @@
+"""Implementations for the jac command line interface."""
+import:py from os, path;
+
+:a:load(filename: str) {
+    if filename.endswith(".jac"){
+        [base, mod] = path.split(filename);
+        base = './' if not base else base;
+        mod=mod[:-4];
+        __jac_import__(target=mod, base_path=base);
+    } else {
+        "Not a .jac file." :> print;
+    }
+}
+
+
+:a:run(filename: str, entrypoint: str, args: list) {
+    if filename.endswith(".jac"){
+        [base, mod] = path.split(filename);
+        base = './' if not base else base;
+        mod=mod[:-4];
+        mod = __jac_import__(target=mod, base_path=base);
+        :> ((mod, entrypoint) :> getattr );
+    } else {
+        "Not a .jac file." :> print;
+    }
+}

jaclang-0.0.3/jaclang/core/impl/__init__.py

@@ -0,0 +1 @@
+"""For setuptools to find this dir."""

jaclang-0.0.3/jaclang/core/impl/arch_impl.jac

@@ -0,0 +1,112 @@
+"""Implementation for Jac's Element Abstractions"""
+import:py from jaclang.jac.constant, EdgeDir;
+
+:o:Node:a:__call__
+(walk: Walker) {
+    if not (walk, Walker) :> isinstance {
+        raise ("Argument must be a Walker instance") :> TypeError;
+    }
+    <self> :> walk;
+}
+
+:o:Node:a:_jac_connect_node_
+(nd: Node, edg: Edge) -> Node {
+    (<self>, nd) :> edg._jac_attach_;
+    return <self>;
+}
+
+:o:Node:a:_jac_edges_to_nodes_
+(dir: EdgeDir) -> list[Node] {
+    ret_nodes = [];
+    if dir in [EdgeDir.OUT, EdgeDir.ANY] {
+        for i in <self>._jac_edges_[EdgeDir.OUT] {
+            ret_nodes.append(i._jac_target_);
+        }
+    } elif dir in [EdgeDir.IN, EdgeDir.ANY] {
+        for i in <self>._jac_edges_[EdgeDir.IN] {
+            ret_nodes.append(i._jac_source_);
+        }
+
+    }
+    return ret_nodes;
+}
+
+:o:Edge:a:__call__
+(walk: Walker) {
+    if not (walk, Walker) :> isinstance {
+        raise ("Argument must be a Walker instance") :> TypeError;
+    }
+    <self>._jac_target_ :> walk;
+}
+
+:o:Edge:a:_jac_apply_dir_
+(dir: EdgeDir) -> Edge {
+    <self>._jac_dir_ = dir;
+    return <self>;
+}
+
+:o:Edge:a:_jac_attach_
+(src: Node, trg: Node) -> Edge {
+    if <self>._jac_dir_ == EdgeDir.IN {
+        <self>._jac_source_ = trg;
+        <self>._jac_target_ = src;
+        <self> :> src._jac_edges_[EdgeDir.IN].append;
+        <self> :> trg._jac_edges_[EdgeDir.OUT].append;
+    } else {
+        <self>._jac_source_ = src;
+        <self>._jac_target_ = trg;
+        <self> :> src._jac_edges_[EdgeDir.OUT].append;
+        <self> :> trg._jac_edges_[EdgeDir.IN].append;
+    }
+
+    return <self>;
+}
+
+:o:Walker:a:__call__
+(nd: Node) {
+    <self>._jac_path_ = [];
+    <self>._jac_next_ = [nd];
+    walker_type = <self>.__class__.__name__;
+    node_type = nd.__class__.__name__;
+    while <self>._jac_next_ :> len {
+        nd = 0 :> <self>._jac_next_.pop;
+
+        for i in nd._jac_ds_entry_funcs {
+            if i['func'].__qualname__.split(".")[0] == node_type and
+                <self>:>type in i['types'] {
+                (nd, <self>) :> i['func'];
+            }
+        }
+        for i in <self>._jac_ds_entry_funcs {
+            if i['func'].__qualname__.split(".")[0] == walker_type and
+                (nd:>type in i['types'] or nd in i['types']) {  # if nd==root direct chec
+                (<self>, nd) :> i['func'];
+            }
+        }
+        for i in <self>._jac_ds_exit_funcs {
+            if i['func'].__qualname__.split(".")[0] == walker_type and
+            (nd:>type in i['types'] or nd in i['types']) {
+                (<self>, nd) :> i['func'];
+            }
+        }
+        for i in nd._jac_ds_exit_funcs {
+            if i['func'].__qualname__.split(".")[0] == node_type and
+                <self>:>type in i['types'] {
+                (nd, <self>) :> i['func'];
+            }
+        }
+        nd :> <self>._jac_path_.append;
+    }
+}
+
+:o:Walker:a:_jac_visit_
+(nds: list[Node]|list[Edge]) {
+    for i in nds {
+        i :> <self>._jac_next_.append;
+    }
+    return nds :> len;
+}
+
+:o:Walker:a:_jac_disengage_ {
+    <self>._jac_next_ = [];
+}

jaclang-0.0.3/jaclang/core/impl/element_impl.jac

@@ -0,0 +1,95 @@
+"""Implementation for Jac's Element Abstractions"""
+
+:enum:AccessMode {
+    READ_ONLY,
+    READ_WRITE,
+    PRIVATE
+}
+
+:object:Element:ability:init
+(_jac_exec_ctx: ExecutionContext) {
+    <self>.__jinfo = _jac_exec_ctx :> ExecutionContext;
+}
+
+:object:Element:ability:_jac_make_public_ro {
+    <self>.__jinfo.access_mode = AccessMode.READ_ONLY;
+}
+
+:object:Element:ability:_jac_make_public_rw {
+    <self>.__jinfo.access_mode = AccessMode.READ_WRITE;
+}
+
+:object:Element:ability:_jac_make_private {
+    <self>.__jinfo.access_mode = AccessMode.PRIVATE;
+}
+
+:object:Element:ability:_jac_is_public_ro -> bool {
+    return <self>.__jinfo.access_mode == AccessMode.READ_ONLY;
+}
+
+:object:Element:ability:_jac_is_public_rw -> bool {
+    return <self>.__jinfo.access_mode == AccessMode.READ_WRITE;
+}
+
+:object:Element:ability:_jac_is_private -> bool {
+    return <self>.__jinfo.access_mode == AccessMode.PRIVATE;
+}
+
+:object:Element:ability:_jac_is_readable
+(caller_id: UUID) -> bool {
+    return (
+            caller_id == <self>.owner_id
+            or |> <self>.is_public_read
+            or caller_id in <self>.ro_access
+            or caller_id in <self>.rw_access
+        );
+}
+
+:object:Element:ability:_jac_is_writable
+(caller_id: UUID) -> bool {
+    return (
+            caller_id == <self>.owner_id
+            or |> <self>.is_public_write
+            or caller_id in <self>.rw_access
+        );
+}
+
+:object:Element:ability:_jac_give_access
+(caller_id: UUID, read_write: bool = False) {
+    if read_write {
+        caller_id |> <self>.rw_access.add;
+    }
+    else {
+        caller_id |> add .> ro_access .> <self>;
+    }
+}
+
+:object:Element:ability:_jac_revoke_access
+(caller_id: UUID) {
+    caller_id |> <self>.ro_access.discard;
+    caller_id |> <self>.rw_access.discard;
+}
+
+:object:Object:ability:_jac_on_entry
+(cls: type, triggers: list) {
+    can decorator(func: callable) -> callable {
+        cls._jac_ds_entry_funcs.append({'types': triggers, 'func': func});
+        can wrapper(*args: list, **kwargs: dict) -> callable {
+            return func(*args, **kwargs);
+        }
+        return wrapper;
+    }
+    return decorator;
+}
+
+:object:Object:ability:_jac_on_exit
+(cls: type, triggers: list) {
+    can decorator(func: callable) -> callable {
+        cls._jac_ds_exit_funcs.append({'types': triggers, 'func': func});
+        can wrapper(*args: list, **kwargs: dict) -> callable {
+            return func(*args, **kwargs);
+        }
+        return wrapper;
+    }
+    return decorator;
+}

jaclang-0.0.3/jaclang/core/impl/exec_ctx_impl.jac

@@ -0,0 +1,17 @@
+"""Implementation for Jac's Element Abstractions"""
+import:py from uuid, UUID, uuid4;
+
+:object:ExecutionContext:a:init
+(master: UUID, memory: Memory) {
+    <self>.master = master;
+    <self>.memory = memory;
+}
+
+:object:ExecutionContext:a:get_root
+() {
+    if <self>.master :> type == UUID {
+        <self>.master = Master();
+    }
+    return <self>.master.root_node;
+}
+

jaclang-0.0.3/jaclang/core/impl/memory_impl.jac

@@ -0,0 +1,57 @@
+"""Implementation for Jac's Element Abstractions"""
+import:py sys;
+
+:object:Memory:ability:get_obj
+(caller_id: UUID, item_id: UUID, override: bool = False) -> Element? {
+    ret = item_id |> <self>.index.get;
+    if override or (ret is not None and caller_id |> ret.__is_readable) {
+        return ret;
+    }
+}
+
+:object:Memory:ability:has_obj
+(item_id: UUID) -> bool {
+    return item_id in <self>.index;
+}
+
+:object:Memory:ability:save_obj
+(caller_id: UUID, item: Element) {
+    if caller_id |> item.is_writable {
+        <self>.index[item.id] = item;
+        if item._persist {
+            item |> <self>.save_obj_list.add;
+        }
+    }
+    <self>.mem[item.id] = item;
+    if item._persist {
+        item |> <self>.save_obj_list.add;
+    }
+}
+
+:object:Memory:ability:del_obj
+(caller_id: UUID, item: Element) {
+    if caller_id |> item.is_writable {
+        <self>.index.pop(item.id);
+        if item._persist {
+            item |> <self>.save_obj_list.remove;
+        }
+    }
+}
+
+:object:Memory:ability:get_object_distribution -> dict {
+    dist = {};
+    for i in |> <self>.index.keys {
+        t = <self>.index[i] |> type;
+        if t in dist {
+            dist[t] += 1;
+        }
+        else {
+            dist[t] = 1;
+        }
+    }
+    return dist;
+}
+
+:object:Memory:ability:get_mem_size -> float {
+    return (<self>.index |> sys.getsizeof) / 1024.0;
+}

jaclang-0.0.3/jaclang/jac/passes/purple/impl/__init__.py

@@ -0,0 +1 @@
+"""For setuptools to find this dir."""

jaclang-0.0.3/jaclang/jac/passes/purple/impl/purple_pygen_pass_impl.jac

@@ -0,0 +1,289 @@
+"""First Jac pass bootstrapped in Jac"""
+import:py from jaclang.jac.constant, Constants as C, EdgeDir;
+
+:object:PurplePygenPass:ability:add_element_import
+(arch: str) {
+    (<self>.preamble, f"from jaclang.core import {arch} as _jac_{arch}_")
+        |> <self>.emit_ln_unique;
+}
+
+:object:PurplePygenPass:ability:add_exec_context {
+    (<self>.preamble, f"from jaclang.core import exec_ctx as {C.EXEC_CONTEXT}")
+        |> <self>.emit_ln_unique;
+}
+
+:object:PurplePygenPass:ability:add_edge_directions {
+    (<self>.preamble, f"from jaclang.jac.constant import EdgeDir as {C.EDGE_DIR}")
+        |> <self>.emit_ln_unique;
+}
+
+:object:PurplePygenPass:ability:needs_jac_import {
+    (<self>.preamble, "from jaclang import jac_purple_import as __jac_import__")
+        |> <self>.emit_ln_unique;
+}
+
+"""
+Sub objects.
+
+name: Name,
+arch_type: Token,
+doc: Optional[DocString],
+decorators: Optional["Decorators"],
+access: Optional[Token],
+base_classes: "BaseClasses",
+body: Optional["ArchBlock"],
+"""
+:object:PurplePygenPass:ability:exit_architype
+(nd: ast.Architype) {
+    |> <self>.add_exec_context;
+    if nd.decorators {
+        (nd, nd.decorators.meta["py_code"]) |> <self>.emit_ln;
+    }
+    arch_type=nd.arch_type.name;
+    arch_insert = "";
+    if arch_type == Tok.KW_OBJECT {
+        "Object" |> <self>.add_element_import;
+        arch_insert = C.OBJECT_CLASS;
+    }
+    elif arch_type == Tok.KW_NODE {
+        "Node" |> <self>.add_element_import;
+        arch_insert = C.NODE_CLASS;
+    }
+    elif arch_type == Tok.KW_EDGE {
+        "Edge" |> <self>.add_element_import;
+        arch_insert = C.EDGE_CLASS;
+    }
+    elif arch_type == Tok.KW_WALKER {
+        "Walker" |> <self>.add_element_import;
+        arch_insert = C.WALKER_CLASS;
+    }
+    if nd.base_classes.base_classes |> len {
+        (nd, f"class {nd.name.meta['py_code']}"
+             f"({nd.base_classes.meta['py_code']}, {arch_insert}):")
+            |> <self>.emit_ln;
+    } else {
+        (nd, f"class {nd.name.meta['py_code']}({arch_insert}):") |> <self>.emit_ln;
+    }
+    <self>.indent_level += 1;
+    if nd.doc {
+        (nd, nd.doc.meta["py_code"]) |> <self>.emit_ln; }
+    if nd.body {
+        (nd, nd.body.meta["py_code"]) |> <self>.emit_ln; }
+    else {
+        nd.name.meta["py_code"] |> <self>.decl_def_missing; }
+    <self>.indent_level -= 1;
+}
+
+
+"""Sub objects.
+
+name: Name,
+is_func: bool,
+is_async: bool,
+doc: Optional[DocString],
+decorators: Optional["Decorators"],
+access: Optional[Token],
+signature: Optional["FuncSignature | TypeSpec | EventSignature"],
+body: Optional["CodeBlock"],
+arch_attached: Optional["ArchBlock"] = None,
+"""
+:object:PurplePygenPass:ability:exit_ability
+(nd: ast.Ability) {
+    "Object" |> <self>.add_element_import;
+    if nd.decorators {
+        (nd, nd.decorators.meta["py_code"]) |> <self>.emit_ln;
+    }
+    if nd.signature:>type == ast.EventSignature and nd.arch_attached and
+        nd.signature.event.name == Tok.KW_ENTRY {
+        type_list = nd.signature.arch_tag_info?.meta?["py_code"] ?: "";
+        (nd, f"@{C.OBJECT_CLASS}._jac_on_entry([{type_list.replace('|', ', ')}])") |> <self>.emit_ln;
+    }
+    elif nd.signature:>type == ast.EventSignature and nd.arch_attached and
+        nd.signature.event.name == Tok.KW_EXIT {
+        type_list = nd.signature.arch_tag_info?.meta?["py_code"] ?: "";
+        (nd, f"@{C.OBJECT_CLASS}._jac_on_exit([{type_list.replace('|', ', ')}])") |> <self>.emit_ln;
+    }
+    if nd.signature:>type in [ast.FuncSignature, ast.EventSignature] {
+        if nd.arch_attached and not nd.is_static {
+            (nd, f"def {nd.name.meta['py_code']}(self{nd.signature.meta['py_code']}:")
+                |> <self>.emit_ln;
+        } else {
+            if nd.arch_attached and nd.is_static {
+                (nd, f"@classmethod") |> <self>.emit_ln;
+            }
+            (nd, f"def {nd.name.meta['py_code']}({nd.signature.meta['py_code']}:")
+                |> <self>.emit_ln;
+        }
+    } else {
+        if nd.arch_attached {
+            (nd, f"def {nd.name.meta['py_code']}(self):") |> <self>.emit_ln;
+        } else {
+            (nd, f"def {nd.name.meta['py_code']}():") |> <self>.emit_ln;
+        }
+    }
+    <self>.indent_level += 1;
+    if nd.doc {
+        (nd, nd.doc.meta["py_code"]) |> <self>.emit_ln;
+    }
+    if nd.body {
+        (nd, "try:") |> <self>.emit_ln;
+        <self>.indent_level += 1;
+        (nd, nd.body.meta["py_code"]) |> <self>.emit;
+        <self>.indent_level -= 1;
+        (nd) |> <self>.emit_jac_error_handler;
+    } else {
+        nd.name.meta["py_code"] |> <self>.decl_def_missing;
+    }
+    <self>.indent_level -= 1;
+}
+
+
+"""Sub objects.
+
+event: Token,
+arch_tag_info: Optional["TypeList | TypeSpec"],
+return_type: Optional["TypeSpec"],
+"""
+:object:PurplePygenPass:ability:exit_event_signature
+(nd: ast.EventSignature) {
+    if (nd.parent|>type) == ast.Ability and nd.parent.arch_attached {
+        (nd, ", ") |> <self>.emit;
+    }
+    if nd.arch_tag_info {
+        (nd, f"{C.HERE}: {nd.arch_tag_info.meta['py_code']})")
+            |> <self>.emit;
+    } else {
+        (nd, f"{C.HERE})") |> <self>.emit;
+    }
+    if nd.return_type {
+        (nd, f" -> {nd.return_type.meta['py_code']}") |> <self>.emit;
+    }
+}
+
+
+"""Sub objects.
+
+ctrl: Token,
+"""
+:object:PurplePygenPass:ability:exit_ctrl_stmt
+(nd: ast.CtrlStmt) {
+    if nd.ctrl.name == Tok.KW_SKIP {
+        (nd, "return") |> <self>.emit_ln;
+    } else {
+        <super>.exit_ctrl_stmt(nd);
+    }
+}
+
+
+"""Sub objects.
+
+vis_type: Optional[Token],
+target: ExprType,
+else_body: Optional["ElseStmt"],
+from_walker: bool = False,
+"""
+:object:PurplePygenPass:ability:exit_visit_stmt
+(nd: ast.VisitStmt) {
+    vis_type = nd.vis_type?.value ?: "";
+    loc = f"{'self' if nd.from_walker else C.HERE}";
+    (nd, f"if not {loc}.{C.WALKER_VISIT}({nd.target.meta['py_code']}): " )
+        |> <self>.emit_ln;
+    <self>.indent_level += 1;
+    if nd.else_body {
+        (nd, nd.else_body.body.meta["py_code"]) |> <self>.emit;
+    } else {
+        (nd, 'pass') |> <self>.emit_ln;
+    }
+    <self>.indent_level -= 1;
+}
+
+
+"""Sub objects.
+from_walker: bool = False,
+"""
+:object:PurplePygenPass:ability:exit_disengage_stmt
+(nd: ast.VisitStmt) {
+    loc = f"{'self' if nd.from_walker else C.HERE}";
+    (nd, f"return {loc}.{C.DISENGAGE}()") |> <self>.emit_ln;
+}
+
+
+"""Sub objects.
+
+left: ExprType,
+right: ExprType,
+op: Token,
+"""
+:object:PurplePygenPass:ability:exit_binary_expr
+(nd: ast.BinaryExpr) {
+    if (nd.op|>type) == ast.ConnectOp {
+        (nd, f"{nd.left.meta['py_code']}.{C.CONNECT_NODE}({nd.right.meta['py_code']}, {nd.op.meta['py_code']})")
+            |> <self>.emit;
+    } else {
+        <super>.exit_binary_expr(nd);
+    }
+}
+
+
+"""Sub objects.
+
+filter_type: Optional[ExprType],
+filter_cond: Optional[FilterCompr],
+edge_dir: EdgeDir,
+"""
+:object:PurplePygenPass:ability:exit_edge_op_ref
+(nd: ast.EdgeOpRef) {
+    edge_dir = f"{C.EDGE_DIR}.IN" if nd.edge_dir == EdgeDir.IN
+               else f"{C.EDGE_DIR}.OUT" if nd.edge_dir == EdgeDir.OUT
+               else f"{C.EDGE_DIR}.ANY";
+    if nd.filter_type and nd.filter_cond {
+        (nd, f"[{C.JAC_TMP} for {C.JAC_TMP} in {C.HERE}.{C.EDGES_TO_NODE}({edge_dir})"
+            f" if isinstance({C.JAC_TMP}, {nd.filter_type.meta['py_code']})"
+            f" and {nd.filter_cond.meta['py_code'].replace(C.PATCH, C.JAC_TMP)}]")
+            |> <self>.emit;
+    }
+    elif nd.filter_type {
+        (nd, f"[{C.JAC_TMP} for {C.JAC_TMP} in {C.HERE}.{C.EDGES_TO_NODE}({edge_dir})"
+            f" if isinstance({C.JAC_TMP}, {nd.filter_type.meta['py_code']})]")
+            |> <self>.emit;
+    }
+    else {
+        (nd, f"{C.HERE}.{C.EDGES_TO_NODE}({edge_dir})")
+            |> <self>.emit;
+    }
+}
+
+
+"""Sub objects.
+
+conn_type: Optional[ExprType],
+conn_assign: Optional[AssignmentList],
+edge_dir: EdgeDir,
+"""
+:object:PurplePygenPass:ability:exit_connect_op
+(nd: ast.ConnectOp) {
+    "Edge" |> <self>.add_element_import;
+    |> <self>.add_edge_directions;
+
+    if nd.conn_type {
+        (nd, f"{nd.conn_type.meta['py_code']}.{C.WITH_DIR}({C.EDGE_DIR}.{nd.edge_dir.name}") |> <self>.emit;
+    } else {
+        (nd, f"{C.EDGE_CLASS}().{C.WITH_DIR}({C.EDGE_DIR}.{nd.edge_dir.name}") |> <self>.emit;
+    }
+    if nd.conn_assign {
+        (nd, f", {nd.conn_assign.meta['py_code']})") |> <self>.emit;
+    } else {
+        (nd, ")") |> <self>.emit;
+    }
+}
+
+"""Sub objects.
+
+conn_type: Optional[ExprType],
+conn_assign: Optional[AssignmentList],
+edge_dir: EdgeDir,
+"""
+:object:PurplePygenPass:ability:exit_disconnect_op
+(nd: ast.DisconnectOp) {
+
+}

{jaclang-0.0.2 → jaclang-0.0.3}/jaclang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.0.2
+Version: 0.0.3
 Summary: UNKNOWN
 Home-page: https://github.com/Jaseci-Labs/jaclang
 Author: Jason Mars

{jaclang-0.0.2 → jaclang-0.0.3}/jaclang.egg-info/SOURCES.txt

@@ -9,8 +9,16 @@ jaclang.egg-info/top_level.txt
 jaclang/cli/__init__.py
 jaclang/cli/cli.jac
 jaclang/cli/cmds.jac
+jaclang/cli/impl/__init__.py
+jaclang/cli/impl/cli_impl.jac
+jaclang/cli/impl/cmds_impl.jac
 jaclang/core/__init__.py
 jaclang/core/primitives.jac
+jaclang/core/impl/__init__.py
+jaclang/core/impl/arch_impl.jac
+jaclang/core/impl/element_impl.jac
+jaclang/core/impl/exec_ctx_impl.jac
+jaclang/core/impl/memory_impl.jac
 jaclang/jac/__init__.py
 jaclang/jac/absyntree.py
 jaclang/jac/constant.py
@@ -39,6 +47,8 @@ jaclang/jac/passes/blue/tests/test_sub_node_pass.py
 jaclang/jac/passes/blue/tests/test_type_analyze_pass.py
 jaclang/jac/passes/purple/__init__.py
 jaclang/jac/passes/purple/purple_pygen_pass.jac
+jaclang/jac/passes/purple/impl/__init__.py
+jaclang/jac/passes/purple/impl/purple_pygen_pass_impl.jac
 jaclang/jac/tests/__init__.py
 jaclang/jac/tests/test_importer.py
 jaclang/jac/tests/test_lexer.py

{jaclang-0.0.2 → jaclang-0.0.3}/setup.py

@@ -2,7 +2,7 @@
 
 from setuptools import find_packages, setup  # type: ignore
 
-VERSION = "0.0.2"
+VERSION = "0.0.3"
 
 setup(
     name="jaclang",