jaclang 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

jaclang/cli/impl/__init__.py

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

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/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/core/impl/__init__.py

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

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/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/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/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/jac/passes/purple/impl/__init__.py

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

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.dist-info → jaclang-0.0.3.dist-info}/METADATA

@@ -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.dist-info → jaclang-0.0.3.dist-info}/RECORD

@@ -2,8 +2,16 @@ jaclang/__init__.py,sha256=n8HR401oKxP7ckVZ1cPYl-HTaYszuKV5y0kSqARu3MQ,194
 jaclang/cli/__init__.py,sha256=RSosEgm2M0H8QS-H1i-qwVrnHcMClY2TGQlGWPRlXYE,175
 jaclang/cli/cli.jac,sha256=ioxo91yk5RHpDy8qhYSxtl4X9U4nHNAuBQks8wkfI5o,1059
 jaclang/cli/cmds.jac,sha256=QjOVFu5-9OTplEqotc49vqm0CqCyT1j_aW-GAf6RwhY,386
+jaclang/cli/impl/__init__.py,sha256=BTgKqQqL0RDRnEdtLK_MhdR-rLSDnw39xLabPKUotqU,39
+jaclang/cli/impl/cli_impl.jac,sha256=2_KsFrNMINzMbNgYG6jRhw3TmARMZ14F5gi_JcV9Z5A,2398
+jaclang/cli/impl/cmds_impl.jac,sha256=HXSLNaDICww2gMy0qWTTU-KFRe29ZyrfDOIxBM8xAeg,719
 jaclang/core/__init__.py,sha256=q35Msw8l4Z37k8ry1OkVfgkMRkG9LY4O6vEayXcN7yA,212
 jaclang/core/primitives.jac,sha256=t--pgZaOAcLqoQ79EYjrRyk5Ef0n3W2HXm6c4GvRSpQ,2786
+jaclang/core/impl/__init__.py,sha256=BTgKqQqL0RDRnEdtLK_MhdR-rLSDnw39xLabPKUotqU,39
+jaclang/core/impl/arch_impl.jac,sha256=A1LJuGNXBhZ0cN_wmSJn_o9tffDu_EUZWgfjjnIWXOk,3063
+jaclang/core/impl/element_impl.jac,sha256=rgu3RcXJ5uRmXKBlEEsVvcADMQgnj3yPL6DDvSScfa8,2486
+jaclang/core/impl/exec_ctx_impl.jac,sha256=blu_ZYWcx0SuXItjJ4oUfnrllvlFUw9eZbff0OXVob8,370
+jaclang/core/impl/memory_impl.jac,sha256=R27OWfEajtZ05RxYxR3hjiLYK7SxS9IQyZ9Q6U__L8g,1364
 jaclang/jac/__init__.py,sha256=OAIBG-7iYvbebyiu0pJ-lFsua8mD6meBkaTylb8XS64,26
 jaclang/jac/absyntree.py,sha256=wE_IeTCDU9IHTP-JRFw3I3SxIfpvs4q6q-eTN5jqAtw,47429
 jaclang/jac/constant.py,sha256=40jhhphWVj_bvEdnPqoH2SflNT74CZPwBSfxKn0hEwo,1107
@@ -32,6 +40,8 @@ jaclang/jac/passes/blue/tests/test_sub_node_pass.py,sha256=V4ABc2Na4YoQ6--TP3nH1
 jaclang/jac/passes/blue/tests/test_type_analyze_pass.py,sha256=cm8Tf3TnwtJpoOXYd1xlZOyCPTmEmt1_Y_McdS2ARBs,2123
 jaclang/jac/passes/purple/__init__.py,sha256=K0I6Pud7QIQl7xkT8wqpWlxQADSl1t7Ab68P1C3vN3g,343
 jaclang/jac/passes/purple/purple_pygen_pass.jac,sha256=cnkOgFL34yVasCcNA2SbDl5QOKpCRatW--jt5EWeOCQ,1125
+jaclang/jac/passes/purple/impl/__init__.py,sha256=BTgKqQqL0RDRnEdtLK_MhdR-rLSDnw39xLabPKUotqU,39
+jaclang/jac/passes/purple/impl/purple_pygen_pass_impl.jac,sha256=UhBBmUHJfKTtga-ntRoric9yAO8bjsPGi1GyUokjViQ,8501
 jaclang/jac/tests/__init__.py,sha256=qiXa5UNRBanGOcplFKTT9a_9GEyiv7goq1OzuCjDCFE,27
 jaclang/jac/tests/test_importer.py,sha256=mb5c6jb_1cQuW11nxwdJ8ezizuYn26GkIY4bnoY_LJQ,743
 jaclang/jac/tests/test_lexer.py,sha256=iyDawkr9YXYFzdOSgw7V0xJsG-V2Q5yuPP_5JZIde20,1950
@@ -53,8 +63,8 @@ jaclang/utils/sly/lex.py,sha256=EyK1PDut3uF22Mc60Kcpa58ybfmV02p8L7ylz_1UVuY,1684
 jaclang/utils/sly/yacc.py,sha256=KKoDgnmAL6DRpRuatC3WpX2TTjvtcDA5SZ25uCudYvo,88197
 jaclang/utils/tests/__init__.py,sha256=8uwVqMsc6cxBAM1DuHLuNuTnzLXqOqM-WRa4ixOMF6w,23
 jaclang/utils/tests/test_fstring_parser.py,sha256=8nZPKhGZA0JNRQ1jhQkXRsjGV6pBK-jKEEf2nFevYK8,1887
-jaclang-0.0.2.dist-info/METADATA,sha256=ou0x0brux0kC4mVQySzNz8RJDTQaWJeoHGVrJ1bQ6tA,213
-jaclang-0.0.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-jaclang-0.0.2.dist-info/entry_points.txt,sha256=aMcbIrHSMsY7_wwAjOWoW6F4RzOgrI49M9JYiOORss0,51
-jaclang-0.0.2.dist-info/top_level.txt,sha256=ZOAoLpE67ozkUJd-v3C59wBNXiteRD8IWPbsYB3M08g,8
-jaclang-0.0.2.dist-info/RECORD,,
+jaclang-0.0.3.dist-info/METADATA,sha256=mn5IRS8lJs-xDIx7z9puVGbswF-_AMm53PE9Kq_DaLo,213
+jaclang-0.0.3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+jaclang-0.0.3.dist-info/entry_points.txt,sha256=aMcbIrHSMsY7_wwAjOWoW6F4RzOgrI49M9JYiOORss0,51
+jaclang-0.0.3.dist-info/top_level.txt,sha256=ZOAoLpE67ozkUJd-v3C59wBNXiteRD8IWPbsYB3M08g,8
+jaclang-0.0.3.dist-info/RECORD,,