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

jaseci/jsorc/jsorc.py

@@ -47,6 +47,7 @@ class JsOrc:
 
     # ------------------ COMMONS ------------------ #
 
+    _config = None
     _backoff_interval = 10
     _running_interval = 0
     __running__ = False
@@ -68,16 +69,23 @@ class JsOrc:
                 key=lambda item: (-item["priority"], -item["date_added"]),
             )
 
+    @classmethod
+    def configure(cls):
+        config: dict = cls.settings("JSORC_CONFIG")
+
+        if cls.db_check():
+            hook = cls.hook()
+            config = hook.get_or_create_glob("JSORC_CONFIG", config)
+
+        cls._config = config
+        cls._backoff_interval = max(5, config.get("backoff_interval", 10))
+        cls._regeneration_queues = config.get("pre_loaded_services", [])
+
     @classmethod
     def run(cls):
         if not cls.__running__:
             cls.__running__ == True
-            config: dict = cls.settings("JSORC_CONFIG")
-            if cls.db_check():
-                hook = cls.hook()
-                config = hook.get_or_create_glob("JSORC_CONFIG", config)
-            cls._backoff_interval = max(5, config.get("backoff_interval", 10))
-            cls._regeneration_queues = config.get("pre_loaded_services", [])
+            cls.configure()
             cls.push_interval(1)
 
     @classmethod
@@ -466,87 +474,92 @@ class JsOrc:
         from jaseci.utils.actions.actions_manager import ActionManager
 
         kube = cls.svc("kube", KubeService)
-        while cls._regeneration_queues:
-            regeneration_queue = cls._regeneration_queues.pop(0)
+        regeneration_queues = cls._regeneration_queues.copy()
+        cls._regeneration_queues.clear()
+        while regeneration_queues:
+            regeneration_queue = regeneration_queues.pop(0)
             service = cls.svc(regeneration_queue)
             hook = cls.hook(use_proxy=service.source["proxy"])
             if not service.is_running() and service.enabled and service.automated:
                 if service.manifest and kube.is_running():
-                    manifest = kube.resolve_manifest(
-                        hook.get_or_create_glob(
-                            service.source["manifest"], service.manifest
-                        ),
-                        *cls.overrided_namespace(
-                            regeneration_queue, service.manifest_type
-                        ),
-                    )
-
-                    rmhists: dict = hook.get_or_create_glob(
-                        "RESOLVED_MANIFEST_HISTORY", {}
-                    )
-
-                    _rmhist = rmhists.get(service.source["manifest"], [{}])[0]
-                    rmhist = deepcopy(_rmhist)
-
-                    for kind, confs in manifest.items():
-                        for name, conf in confs.items():
-                            namespace = conf["metadata"].get("namespace")
+                    try:
+                        manifest = kube.resolve_manifest(
+                            hook.get_or_create_glob(
+                                service.source["manifest"], service.manifest
+                            ),
+                            *cls.overrided_namespace(
+                                regeneration_queue, service.manifest_type
+                            ),
+                        )
+
+                        rmhists: dict = hook.get_or_create_glob(
+                            "RESOLVED_MANIFEST_HISTORY", {}
+                        )
+
+                        _rmhist = rmhists.get(service.source["manifest"], [{}])[0]
+                        rmhist = deepcopy(_rmhist)
+
+                        for kind, confs in manifest.items():
+                            for name, conf in confs.items():
+                                namespace = conf["metadata"].get("namespace")
+
+                                if kind in rmhist and name in rmhist[kind]:
+                                    rmhist[kind].pop(name, None)
+
+                                res = kube.read(kind, name, namespace)
+                                if hasattr(res, "status") and res.status == 404:
+                                    kube.create(kind, name, conf, namespace)
+                                elif not isinstance(res, ApiException):
+                                    config_version = 1
+
+                                    if isinstance(res, dict):
+                                        if "labels" in res["metadata"]:
+                                            config_version = (
+                                                res["metadata"]
+                                                .get("labels", {})
+                                                .get("config_version", 1)
+                                            )
+                                    elif res.metadata.labels:
+                                        config_version = res.metadata.labels.get(
+                                            "config_version", 1
+                                        )
 
-                            if kind in rmhist and name in rmhist[kind]:
-                                rmhist[kind].pop(name, None)
+                                    if config_version != conf.get("metadata").get(
+                                        "labels", {}
+                                    ).get("config_version", 1):
+                                        kube.patch(kind, name, conf, namespace)
+
+                        for kind, confs in rmhist.items():
+                            for name, conf in confs.items():
+                                namespace = conf["metadata"].get("namespace")
+                                res = kube.read(kind, name, namespace, quiet=True)
+                                if not isinstance(res, ApiException) and (
+                                    (isinstance(res, dict) and res.get("metadata"))
+                                    or res.metadata
+                                ):
+                                    if kind not in cls.settings(
+                                        "UNSAFE_KINDS"
+                                    ) or service.manifest_unsafe_paraphrase == cls.settings(
+                                        "UNSAFE_PARAPHRASE"
+                                    ):
+                                        kube.delete(kind, name, namespace)
+                                    else:
+                                        logger.info(
+                                            f"You don't have permission to delete `{kind}` for `{name}` with namespace `{namespace}`!"
+                                        )
 
-                            res = kube.read(kind, name, namespace)
-                            if hasattr(res, "status") and res.status == 404:
-                                kube.create(kind, name, conf, namespace)
-                            elif not isinstance(res, ApiException):
-                                config_version = 1
+                        if _rmhist != manifest:
+                            if service.source["manifest"] not in rmhists:
+                                rmhists[service.source["manifest"]] = [manifest]
+                            else:
+                                rmhists[service.source["manifest"]].insert(0, manifest)
+                            hook.save_glob("RESOLVED_MANIFEST_HISTORY", dumps(rmhists))
+                            hook.commit()
 
-                                if isinstance(res, dict):
-                                    if "labels" in res["metadata"]:
-                                        config_version = (
-                                            res["metadata"]
-                                            .get("labels", {})
-                                            .get("config_version", 1)
-                                        )
-                                elif res.metadata.labels:
-                                    config_version = res.metadata.labels.get(
-                                        "config_version", 1
-                                    )
-
-                                if config_version != conf.get("metadata").get(
-                                    "labels", {}
-                                ).get("config_version", 1):
-                                    kube.patch(kind, name, conf, namespace)
-
-                    for kind, confs in rmhist.items():
-                        for name, conf in confs.items():
-                            namespace = conf["metadata"].get("namespace")
-                            res = kube.read(kind, name, namespace, quiet=True)
-                            if not isinstance(res, ApiException) and (
-                                (isinstance(res, dict) and res.get("metadata"))
-                                or res.metadata
-                            ):
-                                if kind not in cls.settings(
-                                    "UNSAFE_KINDS"
-                                ) or service.manifest_unsafe_paraphrase == cls.settings(
-                                    "UNSAFE_PARAPHRASE"
-                                ):
-                                    kube.delete(kind, name, namespace)
-                                else:
-                                    logger.info(
-                                        f"You don't have permission to delete `{kind}` for `{name}` with namespace `{namespace}`!"
-                                    )
-
-                    if _rmhist != manifest:
-                        if service.source["manifest"] not in rmhists:
-                            rmhists[service.source["manifest"]] = [manifest]
-                        else:
-                            rmhists[service.source["manifest"]].insert(0, manifest)
-                        hook.save_glob("RESOLVED_MANIFEST_HISTORY", dumps(rmhists))
-                        hook.commit()
+                    except Exception as e:
+                        logger.error(f"Unhandled exception: {e}")
 
                 cls.svc_reset(regeneration_queue)
-            sleep(1)
 
         action_manager = cls.get("action_manager", ActionManager)
         action_manager.optimize(jsorc_interval=cls._backoff_interval)

jaseci/jsorc/live_actions.py

@@ -247,6 +247,7 @@ def get_global_actions():
                     h=glob_act_hook,
                     mode="public",
                     name=i,
+                    kind="ability",
                     value=i,
                     persist=False,
                 )

jaseci/prim/ability.py

@@ -27,7 +27,7 @@ class Ability(Element, JacCode, Interp):
         self.preset_in_out = preset_in_out  # Not using _ids convention
         self.access_list = access_list
         Element.__init__(self, *args, **kwargs)
-        JacCode.__init__(self, code_ir)
+        JacCode.__init__(self, code_ir=code_ir)
         Interp.__init__(self)
 
     def run_ability(self, here, visitor):
@@ -35,7 +35,15 @@ class Ability(Element, JacCode, Interp):
         Run ability
         """
         Interp.__init__(self)  # Reset before as result need to be absorbed after
-        self.push_scope(JacScope(parent=self, has_obj=here, here=here, visitor=visitor))
+        self.push_scope(
+            JacScope(
+                parent=self,
+                name=f"a_run:{self.get_jac_ast().loc_str()}",
+                has_obj=here,
+                here=here,
+                visitor=visitor,
+            )
+        )
         self.run_code_block(self.get_jac_ast())
         self.pop_scope()
 

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_dot,
     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):
@@ -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_dot(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/test_jac.py

@@ -165,7 +165,7 @@ class JacTests(TestCaseHelper, TestCase):
         """Test preset function loading"""
         from jaseci.jac.machine.jac_scope import JacScope
 
-        JacScope(None)
+        JacScope(None, None)
         from jaseci.jac.machine.jac_scope import get_global_actions
 
         self.assertGreater(len(get_global_actions()), 5)

jaseci/tests/test_stack.py

@@ -206,3 +206,15 @@ class StackTests(CoreTest):
         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"])