jaseci 1.4.2.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

jaseci/jac/interpreter/sentinel_interp.py

@@ -1,260 +0,0 @@
-"""
-Sentinel interpreter for jac code in AST form
-
-This interpreter should be inhereted from the class that manages state
-referenced through self.
-"""
-
-from jaseci.prim.architype import Architype
-from jaseci.jac.interpreter.interp import Interp
-from jaseci.utils.utils import parse_str_token
-from jaseci.jac.ir.jac_code import jac_ast_to_ir
-from jaseci.jac.machine.jac_scope import JacScope
-from jaseci.prim.ability import Ability
-
-
-class SentinelInterp(Interp):
-    """Jac interpreter mixin for objects that will execute Jac code"""
-
-    def run_start(self, jac_ast):
-        """
-        start: ver_label? element* EOF;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if kid[0].name == "ver_label":
-            self.run_ver_label(kid[0])
-        for i in kid:
-            self.run_element(i)
-
-    def run_ver_label(self, jac_ast):
-        """
-        ver_label: 'version' COLON STRING;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        self.version = parse_str_token(kid[2].token_text())
-
-    def run_element(self, jac_ast):
-        """
-        element: global_var | architype | test;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if kid[0].name == "global_var":
-            self.load_global_var(kid[0])
-        elif kid[0].name == "architype":
-            self.load_architype(kid[0])
-        elif kid[0].name == "test":
-            self.load_test(kid[0])
-
-    def load_global_var(self, jac_ast):
-        """
-        global_var:
-            KW_GLOBAL NAME EQ expression (COMMA NAME EQ expression)* SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        kid = kid[1:]
-        while kid[0].name == "NAME":
-            const_name = kid[0].token_text()
-            if const_name in self.global_vars:
-                self.rt_error(f"Global {const_name} already defined!", kid[0])
-            else:
-                self.run_expression(kid[2])
-                self.global_vars[const_name] = self.pop().value
-            kid = kid[4:] if kid[3].name == "COMMA" else kid[3:]
-
-    def load_architype(self, jac_ast):
-        """
-        architype:
-            KW_NODE NAME (COLON NAME)* (COLON INT)? attr_block
-            | KW_EDGE NAME (COLON NAME)* attr_block
-            | KW_GRAPH NAME graph_block
-            | KW_ASYNC? KW_WALKER NAME namespaces? walker_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-
-        is_async = kid[0].name == "KW_ASYNC" and bool(kid.pop(0))
-
-        name = kid[1].token_text()
-        kind = kid[0].token_text()
-        arch = Architype(
-            m_id=self._m_id,
-            h=self._h,
-            code_ir=jac_ast,
-            name=name,
-            kind=kind,
-            is_async=is_async,
-            parent=self,
-        )
-
-        if len(kid) > 2 and kid[2].name == "COLON":
-            for i in kid[2:]:
-                if i.name == "NAME":
-                    arch.super_archs.append(i.token_text())
-        if self.arch_ids.has_obj_by_name(arch.name, kind=arch.kind):
-            self.arch_ids.destroy_obj_by_name(arch.name, kind=arch.kind)
-        self.arch_ids.add_obj(arch)
-        self.arch_has_preproc(kid[-1], arch)
-        self.arch_can_compile(kid[-1], arch)
-        return arch
-
-    # Note: Sentinels only registers the attr_stmts
-
-    def arch_has_preproc(self, jac_ast, arch):
-        """Helper function to statically compile can stmts for arch"""
-        kid = self.set_cur_ast(jac_ast)
-        if jac_ast.name in ["attr_block", "walker_block"]:
-            for i in kid:
-                if i.name == "attr_stmt" and i.kid[0].name == "has_stmt":
-                    for j in i.kid[0].kid:
-                        if j.name == "has_assign":
-                            has_kid = j.kid
-                            is_private = False
-                            is_anchor = False
-                            if has_kid[0].name == "KW_PRIVATE":
-                                has_kid = has_kid[1:]
-                                is_private = True
-                            if has_kid[0].name == "KW_ANCHOR":
-                                has_kid = has_kid[1:]
-                                is_anchor = True
-                            var_name = has_kid[0].token_text()
-                            if is_private:
-                                arch.private_vars.append(var_name)
-                            if is_anchor and arch.anchor_var is None:
-                                arch.anchor_var = var_name
-                            arch.has_vars.append(var_name)
-        arch.save()
-
-    def arch_can_compile(self, jac_ast, arch):
-        """Helper function to statically compile can stmts for arch"""
-        kid = self.set_cur_ast(jac_ast)
-        self.push_scope(
-            JacScope(parent=self, name=f"a_cgen:{jac_ast.loc_str()}", has_obj=None)
-        )
-        if jac_ast.name in ["attr_block", "walker_block"]:
-            for i in kid:
-                if i.name == "attr_stmt" and i.kid[0].name == "can_stmt":
-                    self.run_can_stmt(i.kid[0], arch)
-        elif jac_ast.name == "graph_block":
-            self.run_can_block(jac_ast.kid[2], arch)
-        self.pop_scope()
-
-    def run_can_block(self, jac_ast, arch):
-        """
-        can_block: (can_stmt)*;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        for i in kid:
-            if i.name == "can_stmt":
-                self.run_can_stmt(i, arch)
-
-    def run_can_stmt(self, jac_ast, obj):
-        """
-        can_stmt:
-            KW_CAN dotted_name (preset_in_out event_clause)? (
-                COMMA dotted_name (preset_in_out event_clause)?
-            )* SEMI
-            | KW_CAN NAME event_clause? code_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        kid = kid[1:]
-        ir = None
-        while True:
-            action_type = "activity"
-            access_list = None
-            preset_in_out = None
-            if kid[0].name == "NAME":
-                action_name = kid[0].token_text()
-            else:
-                action_name = self.run_dotted_name(kid[0])
-            kid = kid[1:]
-            if len(kid) > 0 and kid[0].name == "preset_in_out":
-                preset_in_out = jac_ast_to_ir(kid[0])
-                kid = kid[1:]
-            if len(kid) > 0 and kid[0].name == "event_clause":
-                action_type, access_list = self.run_event_clause(kid[0])
-                kid = kid[1:]
-            if kid[0].name != "code_block":
-                self.check_builtin_action(action_name, jac_ast)
-            else:
-                ir = kid[0]
-            getattr(obj, f"{action_type}_ability_ids").add_obj(
-                Ability(
-                    m_id=self._m_id,
-                    h=self._h,
-                    name=action_name,
-                    kind="ability",
-                    code_ir=ir,
-                    preset_in_out=preset_in_out,
-                    access_list=access_list,
-                    parent=self,
-                )
-            )
-            if not len(kid) or kid[0].name != "COMMA":
-                break
-            else:
-                kid = kid[1:]
-
-    def run_event_clause(self, jac_ast):
-        """
-        event_clause:
-                KW_WITH name_list? (KW_ENTRY | KW_EXIT | KW_ACTIVITY);
-        """
-        kid = self.set_cur_ast(jac_ast)
-        nl = []
-        if kid[1].name == "name_list":
-            nl = self.run_name_list(kid[1])
-        return kid[-1].token_text(), nl
-
-    def load_test(self, jac_ast):
-        """
-        test:
-            KW_TEST NAME? multistring KW_WITH (
-                graph_ref
-                | KW_GRAPH graph_block
-            ) KW_BY (
-                (walker_ref spawn_ctx? (code_block | SEMI))
-                | KW_WALKER walker_block
-            );
-        """
-        kid = self.set_cur_ast(jac_ast)
-        (
-            self.run_multistring(kid[2])
-            if kid[1].name == "NAME"
-            else self.run_multistring(kid[1])
-        )
-        testcase = {
-            "name": kid[1].token_text() if kid[1].name == "NAME" else "",
-            "title": self.pop().value,
-            "graph_ref": None,
-            "graph_block": None,
-            "walker_ref": None,
-            "spawn_ctx": None,
-            "assert_block": None,
-            "walker_block": None,
-            "outcome": None,
-        }
-        kid = kid[4:] if kid[1].name == "NAME" else kid[3:]
-        if kid[0].name == "graph_ref":
-            graph_name = kid[0].kid[-1].token_text()
-            if not self.arch_ids.has_obj_by_name(graph_name, kind="graph"):
-                self.rt_error(f"Graph {graph_name} not found!", kid[0])
-            testcase["graph_ref"] = graph_name
-        else:
-            kid = kid[1:]
-            testcase["graph_block"] = jac_ast_to_ir(kid[0])
-        kid = kid[2:]
-        if kid[0].name == "walker_ref":
-            walker_name = kid[0].kid[-1].token_text()
-            if not self.arch_ids.has_obj_by_name(name=walker_name, kind="walker"):
-                self.rt_error(f"Walker {walker_name} not found!", kid[0])
-            testcase["walker_ref"] = walker_name
-            kid = kid[1:]
-            if kid[0].name == "spawn_ctx":
-                testcase["spawn_ctx"] = jac_ast_to_ir(kid[0])
-                kid = kid[1:]
-            if kid[0].name == "code_block":
-                testcase["assert_block"] = jac_ast_to_ir(kid[0])
-        else:
-            kid = kid[1:]
-            testcase["walker_block"] = jac_ast_to_ir(kid[0])
-
-        self.testcases.append(testcase)

jaseci/jac/interpreter/tests/test_interp.py

@@ -1,42 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class InterpreterTest(CoreTest):
-    """Unit tests for Jac Interpreter / Language features"""
-
-    fixture_src = __file__
-
-    def test_quick_check(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("lang_features.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "quick_check"}])
-        self.assertEqual(ret["report"][0], "edge5")
-
-    def test_has_var_plucking(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("lang_features.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "has_var_plucking"}])
-        self.assertEqual(
-            ret["report"], [["node0", "node1", "node2"], ["edge0", "edge1", "edge2"]]
-        )
-
-    def test_deref_adaptive(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("lang_features.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "deref_adaptive"}])
-        self.assertTrue(ret["report"][0].startswith("junk and stuff"))
-        self.assertEqual(ret["report"][1], {"name": "node0"})
-
-    def test_deref_of_element_fails(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("lang_features.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "deref_of_element_fails"}])
-        self.assertFalse(ret["success"])

jaseci/jac/interpreter/walker_interp.py

@@ -1,249 +0,0 @@
-"""
-Walker interpreter for jac code in AST form
-
-This interpreter should be inhereted from the class that manages state
-referenced through self.
-"""
-
-from jaseci.prim.node import Node
-from jaseci.jac.interpreter.interp import Interp
-from jaseci.jac.jac_set import JacSet
-from jaseci.jac.machine.jac_scope import JacScope
-from jaseci.jac.ir.jac_code import jac_ir_to_ast
-
-
-class WalkerInterp(Interp):
-    """Jac interpreter mixin for objects that will execute Jac code"""
-
-    # Walker only executes statements, sentinels handle attr_stmts
-
-    def run_walker(self, jac_ast):
-        """
-        walker: KW_ASYNC? KW_WALKER NAME namespaces? walker_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        self.scope_and_run(
-            jac_ast if jac_ast.name == "walker_block" else kid[-1],
-            self.run_walker_block,
-            scope_name=f"w_run:{jac_ast.loc_str()}",
-        )
-
-    def run_walker_block(self, jac_ast):
-        """
-        walker_block:
-            LBRACE attr_stmt* walk_entry_block? (
-                statement
-                | walk_activity_block
-            )* walk_exit_block? RBRACE;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        act_list = self.current_node.get_architype().get_entry_abilities()
-        self.auto_trigger_node_actions(act_list=act_list)
-
-        for i in kid:
-            if i.name == "walk_entry_block":
-                self.run_walk_entry_block(i)
-            if i.name == "statement":
-                self.run_statement(i)
-            if i.name == "walk_activity_block":
-                self.run_walk_activity_block(i)
-
-        act_list = self.current_node.get_architype().get_exit_abilities()
-        self.auto_trigger_node_actions(act_list=act_list)
-
-        if not self.yielded and kid[-2].name == "walk_exit_block":
-            self.run_walk_exit_block(kid[-2])
-
-    def run_node_ctx_block(self, jac_ast):
-        """
-        node_ctx_block: name_list code_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        for i in self.run_name_list(kid[0]):
-            if self.current_node.get_architype().is_instance(i):
-                self.run_code_block(kid[1])
-                return
-
-    def run_walk_entry_block(self, jac_ast):
-        """
-        walk_entry_block: KW_WITH KW_ENTRY code_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if self.current_step == 0:
-            self.in_entry_exit = True
-            self.run_code_block(kid[2])
-            self.in_entry_exit = False
-
-    def run_walk_exit_block(self, jac_ast):
-        """
-        walk_exit_block: KW_WITH KW_EXIT code_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        self._stopped = None
-        if len(self.next_node_ids) == 0:
-            self.in_entry_exit = True
-            self.run_code_block(kid[2])
-            self.in_entry_exit = False
-
-    def run_walk_activity_block(self, jac_ast):
-        """
-        walk_activity_block: KW_WITH KW_ACTIVITY code_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        self.run_code_block(kid[2])
-
-    def run_walker_action(self, jac_ast):
-        """
-        walker_action:
-            ignore_action
-            | take_action
-            | disengage_action
-            | yield_action;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        expr_func = getattr(self, f"run_{kid[0].name}")
-        expr_func(kid[0])
-
-    def run_ignore_action(self, jac_ast):
-        """
-        ignore_action: KW_IGNORE expression SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        self.run_expression(kid[1])
-        result = self.pop().value
-        if isinstance(result, Node):
-            self.ignore_node_ids.add_obj(result)
-        elif isinstance(result, JacSet):
-            self.ignore_node_ids.add_obj_list(result)
-        else:
-            self.rt_error(f"{result} is not ignorable type (i.e., nodes)", kid[1])
-
-    def run_take_action(self, jac_ast):
-        """
-        take_action:
-            KW_TAKE (COLON NAME)? expression (SEMI | else_stmt);
-        """
-        kid = self.set_cur_ast(jac_ast)
-        style = "b"
-        if kid[1].name == "COLON":
-            style = kid[2].token_text()
-            kid = kid[2:]
-        self.run_expression(kid[1])
-        result = self.pop().value
-        before = len(self.next_node_ids)
-        if isinstance(result, Node):
-            if style in ["b", "bfs"]:
-                self.next_node_ids.add_obj(result, allow_dups=True)
-            elif style in ["d", "dfs"]:
-                self.next_node_ids.add_obj(result, push_front=True, allow_dups=True)
-            else:
-                self.rt_error(f"{style} is invalid take operation", kid[0])
-        elif isinstance(result, JacSet):
-            if style in ["b", "bfs"]:
-                self.next_node_ids.add_obj_list(result, allow_dups=True)
-            elif style in ["d", "dfs"]:
-                self.next_node_ids.add_obj_list(
-                    result, push_front=True, allow_dups=True
-                )
-            else:
-                self.rt_error(f"{style} is invalid take operation", kid[0])
-        elif result:
-            self.rt_error(f"{result} is not destination type (i.e., nodes)", kid[1])
-        after = len(self.next_node_ids)
-        if before >= after and kid[2].name == "else_stmt":
-            self.run_else_stmt(kid[2])
-        after = len(self.next_node_ids)
-
-    def run_disengage_action(self, jac_ast):
-        """
-        disengage_action: KW_DISENGAGE (report_action | SEMI);
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if kid[1].name == "report_action":
-            self.run_report_action(kid[1])
-        self._stopped = "stop"
-        self.next_node_ids.remove_all()
-
-    def run_yield_action(self, jac_ast):
-        """
-        yield_action:
-            KW_YIELD (
-                report_action
-                | disengage_action
-                | take_action
-                | SEMI
-            );
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if len(kid) and kid[1].name != "SEMI":
-            expr_func = getattr(self, f"run_{kid[1].name}")
-            expr_func(kid[1])
-        self.yield_walk()
-
-    def run_preset_in_out(self, jac_ast, act):
-        """
-        preset_in_out:
-            DBL_COLON param_list? (DBL_COLON | COLON_OUT expression);
-
-        obj: The node or edge with preset
-        act: The action associated with preset
-        """
-        kid = self.set_cur_ast(jac_ast)
-        param_list = {"args": [], "kwargs": []}
-        self.push_scope(
-            JacScope(
-                parent=self,
-                name=f"p_in_out:{jac_ast.loc_str()}",
-                has_obj=self.current_node,
-                here=self.current_node,
-                visitor=self,
-            )
-        )
-
-        if kid[1].name == "param_list":
-            param_list = self.run_param_list(kid[1]).value
-        try:
-            result = act.run_action(param_list, self._jac_scope, self, jac_ast)
-        except Exception as e:
-            self.rt_error(e, jac_ast)
-        if kid[-1].name == "expression":
-            self.run_expression(kid[-1])
-            dest = self.pop()
-            dest.value = result
-            dest.write(kid[-1])
-        self.pop_scope()
-
-    # Helper Functions ##################
-    def auto_trigger_node_actions(self, act_list):
-        already_executed = []  # handles inhereted duplicates, (overriding)
-        nd = self.current_node
-        for i in act_list.obj_list():
-            if (
-                i.access_list
-                and self.name not in i.access_list
-                or i.name in already_executed
-            ):
-                continue
-            if i.preset_in_out:
-                self.run_preset_in_out(jac_ir_to_ast(i.preset_in_out), i)
-            else:
-                self.call_ability(nd=nd, name=i.name, act_list=act_list)
-            if not i.preset_in_out:  # All preset in and outs get executed
-                already_executed.append(i.name)
-
-    def scope_and_run(self, jac_ast, run_func, scope_name):
-        """
-        Helper to run ast elements with execution scope added
-        (Useful for running arbitrary code blocks as one-offs)
-        """
-        self.push_scope(
-            JacScope(
-                parent=self,
-                name=scope_name,
-                has_obj=self,
-                here=self.current_node,
-                visitor=self,
-            )
-        )
-        run_func(jac_ast)
-        self.pop_scope()

jaseci/jac/ir/ast.py

@@ -1,73 +0,0 @@
-"""
-AST for Jac
-"""
-
-from jaseci.utils.utils import logger
-
-
-class Ast:
-    """
-    AST Nodes
-    """
-
-    def __init__(
-        self,
-        mod_name,
-    ):
-        self.name = "unparsed"
-        self.kid = []
-        self.loc = [
-            0,
-            0,
-            mod_name if mod_name is not None else "@default",
-            {},
-        ]  # line, col, module, tokens
-
-    def is_terminal(self):
-        """Returns true if node is a terminal"""
-        return len(self.loc[3].keys())
-
-    def token(self):
-        if not self.is_terminal():
-            logger.error(str(f"Non terminals (rules) don't have token info - {self}"))
-            return None
-        else:
-            return self.loc[3]["token"]
-
-    def token_text(self):
-        if self.is_terminal():
-            return self.token()["text"]
-
-    def token_symbol(self):
-        if self.is_terminal():
-            return self.token()["symbol"]
-
-    def loc_str(self):
-        return f"{self.loc[2]}:{self.loc[0]}"
-
-    def __str__(self):
-        res = f"{self.name}:{self.loc[2]}:{self.loc[0]}:{self.loc[1]}:"
-        if self.is_terminal():
-            res += f':{self.loc[3]["token"]["text"]}'
-        return res
-
-    def __repr__(self):
-        return self.__str__()
-
-    def get_tokens(self):
-        """Return list of all tokens derived from this ast node"""
-        tokens = []
-        if "token" in self.loc[3]:
-            tokens.append(self.loc[3]["token"])
-            return tokens
-        else:
-            for i in self.kid:
-                tokens = tokens + i.get_tokens()
-        return tokens
-
-    def get_text(self):
-        """Get source text for this node"""
-        ret = ""
-        for i in self.get_tokens():
-            ret += f"{i['text']} "
-        return ret