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

jaseci/prim/architype.py

@@ -18,9 +18,9 @@ class Architype(Element, JacCode, ArchitypeInterp):
         self.anchor_var = None
         self.private_vars = []
         self.has_vars = []
-        self.entry_action_ids = IdList(self)
-        self.activity_action_ids = IdList(self)
-        self.exit_action_ids = IdList(self)
+        self.entry_ability_ids = IdList(self)
+        self.activity_ability_ids = IdList(self)
+        self.exit_ability_ids = IdList(self)
 
         # async handling for walker
         self.is_async = is_async
@@ -35,12 +35,27 @@ class Architype(Element, JacCode, ArchitypeInterp):
         """
         return self.run_architype(jac_ast=self.get_jac_ast())
 
-    def get_all_actions(self):
+    def get_actions(self, action_types: list):
         actions = IdList(self, auto_save=False)
         for i in self.arch_with_supers():
-            actions += i.entry_action_ids + i.activity_action_ids + i.exit_action_ids
+            for j in action_types:
+                actions += getattr(i, j)
         return actions
 
+    def get_entry_abilities(self):
+        return self.get_actions(["entry_ability_ids"])
+
+    def get_activity_abilities(self):
+        return self.get_actions(["activity_ability_ids"])
+
+    def get_exit_abilities(self):
+        return self.get_actions(["exit_ability_ids"])
+
+    def get_all_abilities(self):
+        return self.get_actions(
+            ["entry_ability_ids", "activity_ability_ids", "exit_ability_ids"]
+        )
+
     def arch_with_supers(self):
         archs = [self]
         for i in self.super_archs:
@@ -54,6 +69,9 @@ class Architype(Element, JacCode, ArchitypeInterp):
             names += i.super_archs + [i.name]
         return names
 
+    def get_architype(self):
+        return self
+
     def is_instance(self, name):
         return name in self.derived_types()
 
@@ -62,9 +80,9 @@ class Architype(Element, JacCode, ArchitypeInterp):
         Destroys self from memory and persistent storage
         """
         des = (
-            self.activity_action_ids.obj_list()
-            + self.entry_action_ids.obj_list()
-            + self.exit_action_ids.obj_list()
+            self.activity_ability_ids.obj_list()
+            + self.entry_ability_ids.obj_list()
+            + self.exit_ability_ids.obj_list()
         )
         for i in des:
             i.destroy()

jaseci/prim/obj_mixins.py

@@ -207,6 +207,11 @@ class Hookable(Sharable):
             )
         return target._h == self._h
 
+    def make_persistent(self):
+        """Make element persistent"""
+        self._persist = True
+        self.save()
+
     def save(self):
         """
         Write self through hook to persistent storage

jaseci/prim/sentinel.py

@@ -219,7 +219,9 @@ class Sentinel(Element, JacCode, SentinelInterp):
                 if i["assert_block"]:
                     wlk._loop_ctrl = None
                     wlk.scope_and_run(
-                        jac_ir_to_ast(i["assert_block"]), run_func=wlk.run_code_block
+                        jac_ir_to_ast(i["assert_block"]),
+                        run_func=wlk.run_code_block,
+                        scope_name="assert_block",
                     )
                 i["passed"] = True
                 if not silent:

jaseci/prim/walker.py

@@ -10,7 +10,6 @@ from jaseci.utils.utils import (
     logger,
     perf_test_start,
     perf_test_stop,
-    perf_test_to_b64,
     exc_stack_as_str_list,
 )
 from jaseci.prim.element import Element
@@ -22,6 +21,7 @@ import hashlib
 
 from jaseci.jsorc.jsorc import JsOrc
 from jaseci.extens.svc.task_svc import TaskService
+from jaseci.utils.utils import format_jac_profile
 
 
 class Walker(Element, WalkerInterp, Anchored):
@@ -40,6 +40,8 @@ class Walker(Element, WalkerInterp, Anchored):
         self.step_limit = 10000
         self.is_async = is_async
         self._to_await = False
+        if "persist" not in kwargs:  # Default walker persistence to is_async
+            kwargs["persist"] = is_async
         Element.__init__(self, **kwargs)
         WalkerInterp.__init__(self)
         Anchored.__init__(self)
@@ -120,8 +122,6 @@ class Walker(Element, WalkerInterp, Anchored):
 
     def prime(self, start_node, prime_ctx=None, request_ctx=None):
         """Place walker on node and get ready to step step"""
-        if not self.yielded:
-            self.clear_state()
         if not self.yielded or not len(self.next_node_ids):  # modus ponens
             self.next_node_ids.add_obj(start_node, push_front=True)
         if prime_ctx:
@@ -191,8 +191,10 @@ class Walker(Element, WalkerInterp, Anchored):
             report_ret["errors"] = self.runtime_errors
             report_ret["success"] = False
         if profiling:
-            self.profile["perf"] = perf_test_stop(pr)
-            self.profile["graph"] = perf_test_to_b64(pr)
+            self.profile["jac"] = format_jac_profile(self.get_master()._jac_profile)
+            calls, graph = perf_test_stop(pr)
+            self.profile["perf"] = calls
+            self.profile["graph"] = graph
             report_ret["profile"] = self.profile
 
         if self.for_queue():

jaseci/tests/jac_test_progs.py

@@ -746,3 +746,12 @@ walker a {
     }
 }
 """
+
+json_casting = """
+walker json_casting {
+    with entry {
+        report {"test": 1}.str;
+        report '{"test2": 2}'.dict;
+    }
+}
+"""

jaseci/tests/test_jac.py

@@ -165,10 +165,10 @@ class JacTests(TestCaseHelper, TestCase):
         """Test preset function loading"""
         from jaseci.jac.machine.jac_scope import JacScope
 
-        JacScope(None, None, [])
-        from jaseci.jac.machine.jac_scope import global_action_sets
+        JacScope(None, None)
+        from jaseci.jac.machine.jac_scope import get_global_actions
 
-        self.assertGreater(len(global_action_sets), 5)
+        self.assertGreater(len(get_global_actions()), 5)
 
     def test_multiple_edged_between_nodes_work(self):
         """Test that multiple edges between the same two nodes are allowed"""

jaseci/tests/test_node.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
 
 from jaseci.prim.architype import Architype
-from jaseci.prim import action
+from jaseci.prim import ability
 from jaseci.prim.edge import Edge
 from jaseci.prim.node import Node
 from jaseci.jsorc.jsorc import JsOrc
@@ -52,18 +52,15 @@ class NodeTests(TestCaseHelper, TestCase):
     def test_add_entry_action_to_node_and_destroy(self):
         """Test connecting and disconnecting etc of nodes"""
         node1 = Architype(m_id=0, h=JsOrc.hook())
-        act = action.Action(m_id=0, h=node1._h, name="yeah dude", value="SUP")
-        node1.entry_action_ids.add_obj(act)
-        self.assertEqual(
-            node1.entry_action_ids.get_obj_by_name("yeah dude").value, "SUP"
-        )
-        self.assertEqual(len(node1.entry_action_ids), 1)
-        self.assertTrue(node1.entry_action_ids.has_obj_by_name("yeah dude"))
-        self.assertFalse(node1.entry_action_ids.has_obj_by_name("yeah  dude"))
+        act = ability.Ability(m_id=0, h=node1._h, name="yeah dude")
+        node1.entry_ability_ids.add_obj(act)
+        self.assertEqual(len(node1.entry_ability_ids), 1)
+        self.assertTrue(node1.entry_ability_ids.has_obj_by_name("yeah dude"))
+        self.assertFalse(node1.entry_ability_ids.has_obj_by_name("yeah  dude"))
 
-        node1.entry_action_ids.destroy_obj_by_name(name="yeah dude")
-        self.assertEqual(len(node1.entry_action_ids), 0)
-        self.assertFalse(node1.entry_action_ids.has_obj_by_name("yeah dude"))
+        node1.entry_ability_ids.destroy_obj_by_name(name="yeah dude")
+        self.assertEqual(len(node1.entry_ability_ids), 0)
+        self.assertFalse(node1.entry_ability_ids.has_obj_by_name("yeah dude"))
 
     def test_adding_and_removing_from_hdnodes(self):
         """Test adding nodes and removing them from HDGDs"""

jaseci/tests/test_progs.py

@@ -11,7 +11,7 @@ from jaseci.jsorc.jsorc import JsOrc
 from jaseci.jsorc.jsorc_utils import State
 
 
-class JacTests(TestCaseHelper, TestCase):
+class ProgTests(TestCaseHelper, TestCase):
     """Unit tests for Jac language"""
 
     def setUp(self):
@@ -654,3 +654,18 @@ class JacTests(TestCaseHelper, TestCase):
         self.assertTrue(res["success"])
         self.assertTrue(res["report"], [None, None])
         self.assertIsNone(res.get("errors"))
+
+    def test_json_casting(self):
+        mast = JsOrc.master()
+        mast.sentinel_register(name="test", code=jtp.json_casting, auto_run="")
+
+        res = mast.general_interface_to_api(
+            api_name="walker_run",
+            params={"name": "json_casting", "ctx": {}},
+        )
+
+        self.assertTrue(res["success"])
+        self.assertEqual(
+            res["report"],
+            ['{"test": 1}', {"test2": 2}],
+        )

jaseci/tests/test_stack.py

@@ -196,3 +196,25 @@ class StackTests(CoreTest):
         ret = self.call(self.smast, ["walker_run", {"name": "deep_except"}])
         self.assertTrue(ret["success"])
         self.assertIn("xxxx.xxxx", ret["report"][2]["msg"])
+
+    def test_dot_profiling_in_walker(self):
+        ret = self.call(
+            self.mast,
+            ["sentinel_register", {"code": self.load_jac("simple.jac")}],
+        )
+        ret = self.call(self.mast, ["walker_run", {"name": "init", "profiling": True}])
+        self.assertIn("digraph", ret["profile"]["graph"])
+        self.assertIn("jaseci", ret["profile"]["graph"])
+        self.assertGreater(len(ret["profile"]["graph"]), 1000)
+
+    def test_jac_profiling_in_walker(self):
+        ret = self.call(
+            self.mast,
+            ["sentinel_register", {"code": self.load_jac("simple.jac")}],
+        )
+        ret = self.call(
+            self.mast, ["walker_run", {"name": "complex", "profiling": True}]
+        )
+        print(ret["profile"]["jac"])
+        self.assertIn("cum_time", ret["profile"]["jac"])
+        self.assertIn("run_walker", ret["profile"]["graph"])

jaseci/utils/actions/actions_optimizer.py

@@ -21,6 +21,8 @@ import time
 from .actions_state import ActionsState
 
 POLICIES = ["Default", "Evaluation"]
+THRESHOLD = 0.2
+NODE_MEM_THRESHOLD = 0.8
 
 
 class ActionsOptimizer:
@@ -42,6 +44,7 @@ class ActionsOptimizer:
         self.actions_calls = actions_calls
         self.policy_params = {}
         self.policy_state = {}
+        self.last_eval_configs = []
 
     def kube_create(self, config):
         kube = JsOrc.svc("kube").poke(cast=KubeService)
@@ -97,7 +100,8 @@ class ActionsOptimizer:
     def load_action_remote(self, name, unload_existing=False):
         """
         Load a remote action.
-        JSORC will get the URL of the remote microservice and stand up a microservice if there isn't currently one in the cluster.
+        JSORC will get the URL of the remote microservice
+        and stand up a microservice if there isn't currently one in the cluster.
         Return True if the remote action is loaded successfully,
         False otherwise
         """
@@ -137,10 +141,12 @@ class ActionsOptimizer:
         Load an action module
         """
         cur_state = self.actions_state.get_state(name)
+        logger.info(cur_state)
         if cur_state is None:
             cur_state = self.actions_state.init_state(name)
 
         if cur_state["mode"] == "module":
+            logger.info("ALREADY A MODULE LOADED")
             # Check if there is already a local action loaded
             return
 
@@ -257,7 +263,6 @@ class ActionsOptimizer:
             return
         elif self.policy == "Evaluation":
             self._actionpolicy_evaluation()
-
         if len(self.actions_change) > 0:
             self.apply_actions_change()
 
@@ -276,9 +281,16 @@ class ActionsOptimizer:
                     c = copy.deepcopy(con)
                     c[act] = m
                     if m == "local":
-                        c["local_mem"] += action_configs[act].get("remote_memory", 0)
-                        if c["local_mem"] < node_mem:
+                        local_mem_requirement = action_configs[act][
+                            "local_mem_requirement"
+                        ]
+                        c["local_mem"] = c["local_mem"] + local_mem_requirement
+                        if c["local_mem"] < (node_mem * NODE_MEM_THRESHOLD):
                             new_configs.append(dict(c))
+                        else:
+                            logger.info(
+                                f"config dropped for memory constraint: {c},\n\tcurrent node memory: {node_mem}\n\tavailable memory: {(node_mem * NODE_MEM_THRESHOLD)-c['local_mem'] }"
+                            )
                     else:
                         new_configs.append(dict(c))
             all_configs = list(new_configs)
@@ -300,8 +312,12 @@ class ActionsOptimizer:
                 "cur_config": None,  # current active configuration
                 "remain_configs": [],  # remaining configurations that need to be evaluated
                 "past_configs": [],  # configurations already evaluated
-                "eval_phase": 10,  # how long is evaluatin period (in seconds)
-                "perf_phase": 100,  # how long is the performance period (in seconds)
+                "eval_phase": self.policy_params.get(
+                    "eval_phase", 10
+                ),  # how long is evaluatin period (in seconds)
+                "perf_phase": self.policy_params.get(
+                    "perf_phase", 100
+                ),  # how long is the performance period (in seconds)
                 "cur_phase": 0,  # how long the current period has been running
                 "prev_best_config": self.actions_state.get_all_state(),
             }
@@ -434,7 +450,6 @@ class ActionsOptimizer:
                 policy_state["cur_phase"] = 0
                 self.benchmark["active"] = True
                 self.benchmark["requests"] = {}
-
         self.policy_state["Evaluation"] = policy_state
 
     def _get_action_change(self, new_action_state):
@@ -466,7 +481,7 @@ class ActionsOptimizer:
         # But this might change down the line
         for name, change_type in actions_change.items():
             logger.info(f"==Actions Optimizer== Changing {name} {change_type}")
-            if change_type == "to_local" or change_type == "to_module":
+            if change_type in ["to_local", "_to_local", "_to_module", "to_module"]:
                 # Switching from no action loaded to local
                 self.load_action_module(name)
                 del self.actions_change[name]