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

jaseci/VERSION

@@ -1 +1 @@
-1.4.0.19
+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):
         """

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):
@@ -166,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
         )
@@ -200,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(
@@ -226,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

@@ -44,7 +44,7 @@ class ArchitypeInterp(Interp):
 
         kid = self.set_cur_ast(jac_ast)
 
-        self.push_scope(JacScope(parent=self))
+        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,
@@ -173,14 +173,11 @@ class ArchitypeInterp(Interp):
         """
         kid = self.set_cur_ast(jac_ast)
         root_name = self.run_has_root(kid[1])
-        m = Interp(parent_override=self.parent(), caller=self)
-        m.push_scope(JacScope(parent=self, here=self))
         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):

jaseci/jac/interpreter/sentinel_interp.py

@@ -125,7 +125,9 @@ class SentinelInterp(Interp):
     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, has_obj=None))
+        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":
@@ -178,6 +180,7 @@ class SentinelInterp(Interp):
                     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,

jaseci/jac/interpreter/walker_interp.py

@@ -24,6 +24,7 @@ class WalkerInterp(Interp):
         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):
@@ -188,10 +189,10 @@ class WalkerInterp(Interp):
         """
         kid = self.set_cur_ast(jac_ast)
         param_list = {"args": [], "kwargs": []}
-        m = Interp(parent_override=self.parent(), caller=self)
-        m.push_scope(
+        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,
@@ -199,17 +200,18 @@ class WalkerInterp(Interp):
         )
 
         if kid[1].name == "param_list":
-            param_list = m.run_param_list(kid[1]).value
+            param_list = self.run_param_list(kid[1]).value
         try:
             result = act.run_action(param_list, self._jac_scope, self)
         except Exception as e:
-            self.rt_error(f"Internal Exception: {e}", m._cur_jac_ast)
+            self.rt_error(f"Internal Exception: {e}", self._cur_jac_ast)
             result = None
         if kid[-1].name == "expression":
-            m.run_expression(kid[-1])
-            dest = m.pop()
+            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):
@@ -229,13 +231,19 @@ class WalkerInterp(Interp):
             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):
+    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, has_obj=self, here=self.current_node, visitor=self)
+            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

@@ -16,7 +16,12 @@ class Ast:
     ):
         self.name = "unparsed"
         self.kid = []
-        self.loc = [0, 0, mod_name if mod_name is not None else "@default", {}]
+        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"""
@@ -37,6 +42,9 @@ class Ast:
         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():

jaseci/jac/machine/jac_scope.py

@@ -8,12 +8,16 @@ from jaseci.jsorc.live_actions import get_global_actions
 
 
 class JacScope:
-    def __init__(self, parent, has_obj=None, here=None, visitor=None):
+    def __init__(self, parent, name, has_obj=None, here=None, visitor=None):
         self.parent = parent
+        self.name = name
         self.local_scope = {}
         self.has_obj = has_obj if has_obj else self
         self.context = {}
         self.action_sets = []
+        self._start_time = 0  # For profiling
+        self._total_time = 0  # For profiling
+        self._cum_start_time = None
         self.set_refs(here, visitor)
         self.setup_actions()
 

jaseci/jac/machine/machine_state.py

@@ -19,12 +19,16 @@ from jaseci.prim.edge import Edge
 from jaseci.prim.node import Node
 from jaseci.jac.machine.jac_value import JacValue
 from jaseci.jac.jsci_vm.op_codes import JsCmp
+import time
 
 
 class MachineState:
     """Shared interpreter class across both sentinels and walkers"""
 
-    def __init__(self, parent_override=None, caller=None):
+    recur_detect_set = []
+    profile_stack = [None]
+
+    def __init__(self):
         self.report = []
         self.report_status = None
         self.report_custom = None
@@ -32,10 +36,6 @@ class MachineState:
         self.runtime_errors = []
         self.yielded_walkers_ids = IdList(self)
         self.ignore_node_ids = IdList(self)
-        self._parent_override = parent_override
-        if not isinstance(self, Element) and caller:
-            self._m_id = caller._m_id
-            self._h = caller._h
         self._scope_stack = [None]
         self._jac_scope = None
         self._relevant_edges = []
@@ -46,18 +46,14 @@ class MachineState:
         self._loop_limit = 10000
         self._cur_jac_ast = Ast("none")
         self._write_candidate = None
+        self._mast = self.get_master()
+
         self.inform_hook()
 
     def inform_hook(self):
         if hasattr(self, "_h"):
             self._h._machine = self
 
-    def parent(self):  # parent here is always a sentinel
-        if self._parent_override:
-            return self._parent_override
-        else:
-            return Element.parent(self)
-
     def reset(self):
         self.report = []
         self.report_status = None
@@ -69,12 +65,74 @@ class MachineState:
         self._stopped = None
 
     def push_scope(self, scope: JacScope):
+        self.profile_pause()
         self._scope_stack.append(scope)
         self._jac_scope = scope
+        MachineState.profile_stack.append(self._jac_scope)
+        self.profile_in()
+        MachineState.recur_detect_set.append(self.call_name())
 
     def pop_scope(self):
+        MachineState.recur_detect_set.remove(self.call_name())
+        self.profile_out()
         self._scope_stack.pop()
         self._jac_scope = self._scope_stack[-1]
+        MachineState.profile_stack.pop()
+        self.profile_unpause()
+
+    def profile_in(self):
+        if self._mast and self._mast._profiling:
+            self._jac_scope._start_time = time.time()
+            self._jac_scope._cum_start_time = time.time()
+
+    def profile_out(self):
+        # profile_jac_scope = MachineState.profile_stack[-1]  # refactor and clean
+        if self._mast and self._mast._profiling:
+            name = self.call_name()
+            if name not in self._mast._jac_profile:
+                self._mast._jac_profile[name] = {
+                    "calls": 1,
+                    "u_calls": 0 if name in MachineState.recur_detect_set else 1,
+                    "tot_time": self._jac_scope._total_time
+                    + (time.time() - self._jac_scope._start_time),
+                    "cum_time": 0
+                    if name in MachineState.recur_detect_set
+                    else time.time() - self._jac_scope._cum_start_time,
+                }
+            else:
+                c = self._mast._jac_profile[name]["calls"]
+                u = self._mast._jac_profile[name]["u_calls"]
+                t = self._mast._jac_profile[name]["tot_time"]
+                p = self._mast._jac_profile[name]["cum_time"]
+                self._mast._jac_profile[name]["calls"] = c + 1
+                self._mast._jac_profile[name]["u_calls"] = (
+                    u if name in MachineState.recur_detect_set else u + 1
+                )
+                self._mast._jac_profile[name][
+                    "tot_time"
+                ] += self._jac_scope._total_time + (
+                    time.time() - self._jac_scope._start_time
+                )
+
+                self._mast._jac_profile[name]["cum_time"] = (
+                    p
+                    if name in MachineState.recur_detect_set
+                    else (p + time.time() - self._jac_scope._cum_start_time)
+                )
+
+    def call_name(self):
+        return f"{self.kind}::{self.name}:{self._jac_scope.name}"
+
+    def profile_pause(self):
+        _jac_scope = MachineState.profile_stack[-1]  # refactor and clean
+        if self._mast and self._mast._profiling and _jac_scope:
+            _jac_scope._total_time += time.time() - _jac_scope._start_time
+            _jac_scope._start_time = 0
+
+    def profile_unpause(self):
+        _jac_scope = MachineState.profile_stack[-1]  # refactor and clean
+        if self._mast and self._mast._profiling and _jac_scope:
+            _jac_scope._start_time = time.time()
 
     def here(self):
         return self._scope_stack[-1].here() if self._scope_stack[-1] else None