jaseci 1.4.0.18__py3-none-any.whl → 1.4.0.20__py3-none-any.whl

jaseci/VERSION

@@ -1 +1 @@
-1.4.0.18
+1.4.0.20

jaseci/cli_tools/jsctl.py

@@ -17,6 +17,7 @@ from jaseci.utils.utils import copy_func
 from .book_tools import Book, modifiedBook
 from jaseci.utils.utils import logger, perf_test_start, perf_test_stop, find_first_api
 from jaseci.jsorc.jsorc import JsOrc
+from prettytable import PrettyTable
 
 session = None
 
@@ -112,6 +113,39 @@ def resolve_none_type(kwargs):
             kwargs[i] = None
 
 
+def has_profile(output):
+    if isinstance(output, dict):
+        if "profile" in output.keys():
+            if "jac" in output["profile"].keys() and "perf" in output["profile"].keys():
+                return True
+    return False
+
+
+def gen_pretty_table(csv_str):
+    rows = csv_str.split("\n")
+    row_width = len(rows[0].split(","))
+    first_row = rows[0].split(",")
+    if first_row[2] == "percall":
+        first_row[2] = "percall_tot"
+    try:
+        table = PrettyTable(first_row)
+        for i in rows[1:]:
+            row = i.split(",")
+            if len(row) != row_width:
+                continue
+            table.add_row(row)
+        return table
+    except Exception as e:
+        click.echo(f"Something went wrong pretty printing profile: {e}")
+
+
+def pretty_profile(output):
+    click.echo("Jac Code Profile:")
+    click.echo(gen_pretty_table(output["profile"]["jac"]))
+    click.echo("\nInternal Jaseci Profile:")
+    click.echo(gen_pretty_table(output["profile"]["perf"]))
+
+
 def interface_api(api_name, is_public, is_cli_only, **kwargs):
     """
     Interfaces Master apis after processing arguments/parameters
@@ -137,6 +171,7 @@ def interface_api(api_name, is_public, is_cli_only, **kwargs):
         out = session["master"].public_interface_to_api(kwargs, api_name)
     else:
         out = session["master"].general_interface_to_api(kwargs, api_name)
+    d_out = out
     if (
         isinstance(out, dict)
         and "report_custom" in out.keys()
@@ -153,6 +188,8 @@ def interface_api(api_name, is_public, is_cli_only, **kwargs):
     if not session["mem-only"]:
         with open(session["filename"], "wb") as f:
             pickle.dump(session, f)
+    if has_profile(d_out):
+        pretty_profile(d_out)
 
 
 def extract_api_tree():
@@ -384,20 +421,22 @@ def script(filename, profile, output):
         with open(output, "w") as f:
             f.write("Multi Command Script Output:\n")
     for i in cmds:
-        res = CliRunner(mix_stderr=False).invoke(jsctl, i.split())
+        res = CliRunner(mix_stderr=False).invoke(jsctl, i)
         click.echo(res.stdout)
         if output:
             with open(output, "a") as f:
                 f.write(f"Output for {i}:\n")
                 f.write(res.stdout)
     if profile:
-        perf = perf_test_stop(prof)
+        perf, graph = perf_test_stop(prof)
         click.echo(perf)
+        click.echo(graph)
     if output:
         with open(output, "a") as f:
             if profile:
                 f.write(f"\nProfile:\n")
                 f.write(perf)
+                f.write(graph)
         click.echo(f"[saved to {output}]")
 
 

jaseci/cli_tools/tests/test_jsctl.py

@@ -506,6 +506,17 @@ class JsctlTest(TestCaseHelper, TestCase):
             ],
         )
 
+    def test_jsctl_pretty_profiles(self):
+        self.call(f"actions load local {self.infer_loc}")
+        r = self.call(
+            f"sentinel register "
+            f"{os.path.dirname(__file__)}/graph_can.jac -name gc -set_active true"
+        )
+        r = self.call("walker run go -profiling true")
+        self.assertIn("walker::go", r)
+        self.assertIn("cumtime", r)
+        self.assertIn("cum_time", r)
+
 
 class JsctlTestWithSession(TestCaseHelper, TestCase):
     """Unit tests for Jac language"""

jaseci/extens/act_lib/internal.py

@@ -14,4 +14,5 @@ def start_perf_test(name: str = "default"):
 def stop_perf_test(name: str = "default"):
     if name not in perf_tests.keys():
         return
-    return perf_test_stop(perf_tests[name])
+    calls, graph = perf_test_stop(perf_tests[name])
+    return {"calls": calls, "graph": graph}

jaseci/extens/act_lib/std.py

@@ -11,6 +11,7 @@ from jaseci.extens.svc.elastic_svc import Elastic
 
 import sys
 import json
+import time
 
 
 @jaseci_action()
@@ -49,6 +50,12 @@ def err(*args):
     print(*args, file=sys.stderr)
 
 
+@jaseci_action()
+def sleep(secs: float):
+    """Standard built in for sleep"""
+    return time.sleep(secs)
+
+
 @jaseci_action()
 def sort_by_col(lst: list, col_num: int, reverse: bool = False):
     """

jaseci/extens/act_lib/tests/test_std_lib.py

@@ -21,7 +21,9 @@ class StdLibTest(CoreTest):
         ret = self.call(self.mast, ["walker_run", {"name": "internal_lib"}])
         self.assertEqual(len(ret["report"]), 1)
         self.assertTrue(
-            ret["report"][0].startswith("ncalls,tottime,percall,cumtime,percall,")
+            ret["report"][0]["calls"].startswith(
+                "ncalls,tottime,percall,cumtime,percall,"
+            )
         )
 
     def test_rand_float_round(self):

jaseci/extens/api/jsorc_api.py

@@ -88,6 +88,37 @@ class JsOrcApi:
 
         return new_config
 
+    @Interface.admin_api()
+    def jsorc_refresh(self):
+        """
+        refreshing jsorc's config.
+        """
+
+        JsOrc.configure()
+
+        return {
+            "running_interval": JsOrc._running_interval,
+            "config": JsOrc._config,
+        }
+
+    @Interface.admin_api(cli_args=["name"])
+    def service_info(self, name: str):
+        """
+        getting service's info.
+        """
+
+        # will throw exception if not existing
+        svc = JsOrc.svc(name)
+
+        return {
+            "enabled": svc.enabled,
+            "automated": svc.automated,
+            "quiet": svc.quiet,
+            "state": svc.state.name,
+            "config": svc.config,
+            "error": str(svc.error) if svc.error else None,
+        }
+
     @Interface.admin_api(cli_args=["name"])
     def service_refresh(self, name: str):
         """
@@ -261,7 +292,16 @@ class JsOrcApi:
         return {"success": True, "policy": policy}
 
     @Interface.admin_api()
-    def jsorc_loadtest(self, test: str, experiment: str = "", mem: int = 0):
+    def jsorc_loadtest(
+        self,
+        test: str,
+        experiment: str = "",
+        mem: int = 0,
+        policy: str = "all_local",
+        experiment_duration: int = 180,
+        eval_phase: int = 10,
+        perf_phase: int = 100,
+    ):
         """
         load test API. overwritten in jaseci_serv
         """

jaseci/extens/api/walker_api.py

@@ -22,6 +22,11 @@ class WalkerApi:
     def __init__(self):
         self.spawned_walker_ids = IdList(self)
         self.yielded_walkers_ids = IdList(self)
+        self.reset_profiling(False)
+
+    def reset_profiling(self, profiling):
+        self._profiling = profiling
+        self._jac_profile = {}
 
     @Interface.private_api(cli_args=["wlk"])
     def walker_get(self, wlk: Walker, mode: str = "default", detailed: bool = False):
@@ -64,6 +69,7 @@ class WalkerApi:
         Creates new instance of walker and returns new walker object
         """
         wlk = snt.run_architype(name=name, kind="walker", caller=self, is_async=False)
+        wlk.make_persistent()
         if wlk:
             if self.spawned_walker_ids.has_obj_by_name(name):
                 self.spawned_walker_ids.destroy_obj_by_name(name)
@@ -165,6 +171,7 @@ class WalkerApi:
         """
         Executes walker (assumes walker is primed)
         """
+        self.reset_profiling(profiling)
         return wlk.run(
             start_node=prime, prime_ctx=ctx, request_ctx=_req_ctx, profiling=profiling
         )
@@ -199,6 +206,7 @@ class WalkerApi:
         Creates walker instance, primes walker on node, executes walker,
         reports results, and cleans up walker instance.
         """
+        self.reset_profiling(profiling)
         wlk = self.yielded_walkers_ids.get_obj_by_name(name, silent=True)
         if wlk is None:
             wlk = snt.run_architype(
@@ -225,6 +233,7 @@ class WalkerApi:
         """
         Walker individual APIs
         """
+        self.reset_profiling(profiling)
         return self.walker_run(name, nd, ctx, _req_ctx, snt, profiling)
 
     @Interface.public_api(cli_args=["wlk"])

jaseci/jac/interpreter/architype_interp.py

@@ -9,6 +9,7 @@ from jaseci.prim.edge import Edge
 from jaseci.prim.walker import Walker
 from jaseci.jac.interpreter.interp import Interp
 from jaseci.jac.machine.jac_scope import JacScope
+from jaseci.jac.machine.jac_value import JacValue
 
 
 class ArchitypeInterp(Interp):
@@ -43,7 +44,7 @@ class ArchitypeInterp(Interp):
 
         kid = self.set_cur_ast(jac_ast)
 
-        self.push_scope(JacScope(parent=self, has_obj=self, action_sets=[]))
+        self.push_scope(JacScope(parent=self, name=f"spawn:{jac_ast.loc_str()}"))
         if kid[0].name == "KW_NODE":
             item = Node(
                 m_id=self._m_id,
@@ -78,6 +79,7 @@ class ArchitypeInterp(Interp):
             )
             if kid[2].name == "namespaces":
                 item.namespaces = self.run_namespaces(jac_ast.kid[2])
+            self.build_object_with_supers(item, kid[-1])
         elif jac_ast.name == "graph_block":  # usedi n jac tests
             item = self.run_graph_block(jac_ast)
         self.pop_scope()
@@ -89,6 +91,19 @@ class ArchitypeInterp(Interp):
         """
         return self.run_name_list(jac_ast.kid[1])
 
+    def run_walker_block(self, jac_ast, obj):
+        """
+        walker_block:
+            LBRACE attr_stmt* walk_entry_block? (
+                statement
+                | walk_activity_block
+            )* walk_exit_block? RBRACE;
+        """
+        kid = self.set_cur_ast(jac_ast)
+        for i in kid:
+            if i.name == "attr_stmt":
+                self.run_attr_stmt(jac_ast=i, obj=obj)
+
     def run_attr_block(self, jac_ast, obj):
         """
         attr_block:
@@ -101,52 +116,68 @@ class ArchitypeInterp(Interp):
             if i.name == "attr_stmt":
                 self.run_attr_stmt(i, obj)
 
-    def run_struct_block(self, jac_ast):
+    def run_attr_stmt(self, jac_ast, obj):
         """
-        struct_block: LBRACE (has_stmt)* RBRACE | COLON has_stmt | SEMI;
+        attr_stmt: has_stmt | can_stmt;
         """
         kid = self.set_cur_ast(jac_ast)
-        ret = {}
-        for i in kid:
-            if i.name == "has_stmt":
-                self.run_has_stmt(i, ret)
-        return ret
+        if kid[0].name == "has_stmt":
+            self.run_has_stmt(kid[0], obj)
+        #  Can statements in architype handled in architype load
 
-    def run_can_block(self, jac_ast):
+    def run_has_stmt(self, jac_ast, obj):
         """
-        can_block: (can_stmt)*;
+        has_stmt: KW_HAS has_assign (COMMA has_assign)* SEMI;
         """
         kid = self.set_cur_ast(jac_ast)
         for i in kid:
-            if i.name == "can_stmt":
-                self.run_can_stmt(i, self)
+            if i.name == "has_assign":
+                self.run_has_assign(i, obj)
 
-    def run_graph_block(self, jac_ast):
+    def run_has_assign(self, jac_ast, obj):
         """
-        graph_block: graph_block_spawn;
+        has_assign: KW_PRIVATE? KW_ANCHOR? (NAME | NAME EQ expression);
         """
         kid = self.set_cur_ast(jac_ast)
-        return getattr(self, f"run_{kid[0].name}")(kid[0])
+        while kid[0].name in ["KW_PRIVATE", "KW_ANCHOR"]:
+            kid = kid[1:]
+        var_name = kid[0].token_text()
+        var_val = None  # jac's null
+        if len(kid) > 1:
+            self.run_expression(kid[2])
+            var_val = self.pop().value
+        if isinstance(obj, dict):
+            obj[var_name] = var_val
+        # Runs only once for walkers
+        elif var_name not in obj.context.keys() or obj.j_type != "walker":
+            JacValue(
+                self, ctx=obj, name=var_name, value=var_val, create_mode=True
+            ).write(kid[0], force=True)
 
-    def run_graph_block_spawn(self, jac_ast):
+    def run_struct_block(self, jac_ast):
+        """
+        struct_block: LBRACE (has_stmt)* RBRACE | COLON has_stmt | SEMI;
+        """
+        kid = self.set_cur_ast(jac_ast)
+        ret = {}
+        for i in kid:
+            if i.name == "has_stmt":
+                self.run_has_stmt(i, ret)
+        return ret
+
+    def run_graph_block(self, jac_ast):
         """
-        graph_block_spawn:
+        graph_block:
             LBRACE has_root can_block KW_SPAWN code_block RBRACE
             | COLON has_root can_block KW_SPAWN code_block SEMI;
         """
         kid = self.set_cur_ast(jac_ast)
         root_name = self.run_has_root(kid[1])
-        self.run_can_block(kid[2])
-        m = Interp(parent_override=self.parent(), caller=self)
-        m.push_scope(
-            JacScope(parent=self, has_obj=None, action_sets=[self.activity_action_ids])
-        )
         try:
-            m.run_code_block(kid[4])
+            self.run_code_block(kid[4])
         except Exception as e:
-            self.rt_error(f"Internal Exception: {e}", m._cur_jac_ast)
-        local_state = m._jac_scope.local_scope
-        self.report = self.report + m.report
+            self.rt_error(f"Internal Exception: {e}", self._cur_jac_ast)
+        local_state = self._jac_scope.local_scope
         if root_name in local_state.keys():
             obj = local_state[root_name]
             if not isinstance(obj, Node):
@@ -173,5 +204,9 @@ class ArchitypeInterp(Interp):
                 .get_jac_ast()
                 .kid[-1]
             )
-            self.run_attr_block(super_jac_ast, item)
-        self.run_attr_block(jac_ast, item)
+            self.run_attr_block(super_jac_ast, item) if not isinstance(
+                item, Walker
+            ) else self.run_walker_block(super_jac_ast, item)
+        self.run_attr_block(jac_ast, item) if not isinstance(
+            item, Walker
+        ) else self.run_walker_block(jac_ast, item)