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

jaseci/jac/machine/jac_scope.py

@@ -3,30 +3,29 @@ Variable scope manager for Jac
 
 Utility for all runtime interaction with variables in different scopes
 """
-from jaseci.utils.id_list import IdList
 from jaseci.jac.machine.jac_value import JacValue
 from jaseci.jsorc.live_actions import get_global_actions
 
-global_action_sets = None
-
 
 class JacScope:
-    def __init__(self, parent, has_obj, action_sets):
+    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 = action_sets
+        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()
 
     def setup_actions(self):
-        global global_action_sets
-        if global_action_sets is None:
-            global_action_sets = self.group_actions(get_global_actions())
         allactions = []
         for i in self.action_sets:
             allactions += i.obj_list()
-        self.action_sets = global_action_sets
+        self.action_sets = get_global_actions()
         for i in allactions:
             self.add_action(i)
 
@@ -40,33 +39,27 @@ class JacScope:
         else:
             self.action_sets[group] = act
 
-    def group_actions(self, act_list):
-        action_sets = {}
-        for act in act_list:
-            group = act.name.split(".")[0]
-            if "." in act.name:
-                if group not in action_sets.keys():
-                    action_sets[group] = {}
-                action = act.name.split(".")[1]
-                action_sets[group][action] = act
-            else:
-                action_sets[group] = act
-        return action_sets
-
-    def set_agent_refs(self, cur_node, cur_walker):
-        self.local_scope["here"] = cur_node
-        self.local_scope["visitor"] = cur_walker
-
-    def inherit_agent_refs(self, src_scope, src_node):  # used for calls of abilities
-        self.local_scope["here"] = src_node
-        self.local_scope["visitor"] = src_scope.local_scope["visitor"]
+    def set_refs(self, here, visitor):
+        self.local_scope["here"] = here
+        self.local_scope["visitor"] = visitor
+        self.action_sets = []
+        if here:
+            self.action_sets += [here.get_architype().get_all_abilities()]
+        if visitor:
+            self.action_sets += [visitor.get_architype().get_all_abilities()]
 
-    def get_aganet_refs(self):
+    def get_refs(self):
         return {
             "here": self.local_scope["here"],
             "visitor": self.local_scope["visitor"],
         }
 
+    def here(self):
+        return self.local_scope["here"]
+
+    def visitor(self):
+        return self.local_scope["visitor"]
+
     def find_live_attr(self, name, allow_read_only=True):
         """Finds binding for variable if not in standard scope"""
         # check if var is in walker's context

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,80 @@ 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
+
+    def visitor(self):
+        return self._scope_stack[-1].visitor() if self._scope_stack[-1] else None
 
     def set_cur_ast(self, jac_ast):
         self._cur_jac_ast = jac_ast
@@ -164,7 +228,7 @@ class MachineState:
         """
         ret = JacSet()
         if not location:
-            location = self.current_node
+            location = self.here()
         for i in edge_set.obj_list():
             ret.add_obj(i.opposing_node(location))
         return ret

jaseci/jsorc/jsorc.py

@@ -3,7 +3,7 @@ import psycopg2
 
 from time import sleep
 from copy import deepcopy
-from json import dumps, loads
+from json import dumps
 from datetime import datetime
 from typing import TypeVar, Any, Union
 
@@ -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

@@ -16,6 +16,9 @@ live_actions = {}  # {"act.func": func_obj, ...}
 live_action_modules = {}  # {__module__: ["act.func1", "act.func2", ...], ...}
 action_configs = {}  # {"module_name": {}, ...}
 
+glob_act_group = {}  # {"group_name": {"act_name": action, ...}, ...}
+glob_act_hook = None
+
 
 def jaseci_action(act_group=None, aliases=list(), allow_remote=False):
     """Decorator for Jaseci Action interface"""
@@ -215,38 +218,40 @@ def get_global_actions():
     Loads all global action hooks for use by Jac programs
     Attaches globals to mem_hook
     """
-    from jaseci.prim.action import Action
+    from jaseci.prim.ability import Ability
     from jaseci.jsorc.memory import MemoryHook
 
-    global_action_list = []
-    hook = MemoryHook()
-    for i in live_actions.keys():
-        if (
-            i.startswith("std.")
-            or i.startswith("file.")
-            or i.startswith("net.")
-            or i.startswith("rand.")
-            or i.startswith("vector.")
-            or i.startswith("request.")
-            or i.startswith("date.")
-            or i.startswith("jaseci.")
-            or i.startswith("internal.")
-            or i.startswith("zip.")
-            or i.startswith("webtool.")
-            or i.startswith("url.")
-            or i.startswith("regex.")
-        ):
-            global_action_list.append(
-                Action(
+    if not glob_act_group:
+        glob_act_hook = MemoryHook()
+        for i in live_actions.keys():
+            name = i.split(".")
+            if name[0] in [
+                "std",
+                "file",
+                "net",
+                "rand",
+                "vector",
+                "request",
+                "date",
+                "jaseci",
+                "internal",
+                "zip",
+                "webtool",
+                "url",
+                "regex",
+            ]:
+                if name[0] not in glob_act_group:
+                    glob_act_group[name[0]] = {}
+                glob_act_group[name[0]][name[1]] = Ability(
                     m_id=0,
-                    h=hook,
+                    h=glob_act_hook,
                     mode="public",
                     name=i,
+                    kind="ability",
                     value=i,
                     persist=False,
                 )
-            )
-    return global_action_list
+    return glob_act_group
 
 
 def unload_remote_actions(url):

jaseci/jsorc/redis.py

@@ -5,7 +5,7 @@ core engine.
 import json
 
 import jaseci as core_mod
-from jaseci.utils.json_handler import JaseciJsonDecoder
+from jaseci.utils.json_handler import JaseciJsonDecoder, jsci_dict_normalize
 from jaseci.jsorc.memory import MemoryHook
 from jaseci.jsorc.jsorc import JsOrc
 from jaseci.extens.svc.redis_svc import RedisService
@@ -45,11 +45,13 @@ class RedisHook(MemoryHook):
                 j_master = jdict["j_master"]
                 class_for_type = self.find_class_and_import(j_type, core_mod)
                 ret_obj = class_for_type(h=self, m_id=j_master, auto_save=False)
-                ret_obj.json_load(loaded_obj)
+                jsci_dict_normalize(jdict, parent_obj=ret_obj)
+                ret_obj.dict_load(jdict)
 
                 super().commit_obj_to_cache(ret_obj)
-                return ret_obj
-
+                obj = ret_obj
+        if obj:
+            obj._persist = True
         return obj
 
     def has_obj_in_store(self, item_id):
@@ -122,7 +124,7 @@ class RedisHook(MemoryHook):
     def decommit_obj_from_cache(self, item):
         super().decommit_obj_from_cache(item)
 
-        if self.redis.is_running():
+        if item._persist and self.redis.is_running():
             self.redis.delete(item.jid)
 
     ###################################################

jaseci/prim/{action.py → ability.py}

@@ -3,7 +3,7 @@ Action class for Jaseci
 
 Each action has an id, name, timestamp and it's set of edges.
 """
-from .item import Item
+from jaseci.prim.element import Element
 from jaseci.jsorc.live_actions import live_actions
 from jaseci.jac.jac_set import JacSet
 import inspect
@@ -11,53 +11,56 @@ import time
 
 from jaseci.jsorc.jsorc import JsOrc
 from jaseci.utils.actions.actions_manager import ActionManager
+from jaseci.jac.ir.jac_code import JacCode
+from jaseci.jac.interpreter.interp import Interp
+from jaseci.jac.machine.jac_scope import JacScope
 
-# ACTION_PACKAGE = 'jaseci.actions.'
 
-
-class Action(Item):
+class Ability(Element, JacCode, Interp):
     """
-    Action class for Jaseci
-
-    preset_in_out holds a set of parameters in the form of lists of context
-    objects that are to be used from whereever those contexts are attached
-    e.g., (nodes, edges, walkers, etc). This is used by Jac's runtime
-    engine to support preset actions in nodes
-    access_list is used by walker to decide what to trigger
+    Abilities class for Jaseci
     """
 
-    def __init__(self, preset_in_out=None, access_list=None, **kwargs):
+    def __init__(
+        self, code_ir=None, preset_in_out=None, access_list=None, *args, **kwargs
+    ):
         self.preset_in_out = preset_in_out  # Not using _ids convention
         self.access_list = access_list
-        Item.__init__(self, **kwargs)
+        Element.__init__(self, *args, **kwargs)
+        JacCode.__init__(self, code_ir=code_ir)
+        Interp.__init__(self)
 
-    def do_auto_conversions(self, args, params):
+    def run_ability(self, here, visitor):
         """
-        Automatically make conversions for jac to internal, e.g., list to jac_set
+        Run ability
         """
+        Interp.__init__(self)  # Reset before as result need to be absorbed after
+        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()
 
-        for i in args.annotations.keys():
-            if args.annotations[i] == JacSet:
-                idx = args.args.index(i)
-                if idx < len(params["args"]):
-                    params["args"][idx] = JacSet(in_list=params["args"][idx])
-                if i in params["kwargs"]:
-                    params["kwargs"][i] = JacSet(in_list=params["kwargs"][i])
-
-    def trigger(self, param_list, scope, interp):
+    def run_action(self, param_list, scope, interp):
         """
         param_list should be passed as list of values to lib functions
         Also note that Jac stores preset_in_out as input/output list of hex
         ids since preset_in_out doesn't use _ids convention
         """
-        if not interp.check_builtin_action(self.value):
-            interp.rt_error(f"Cannot execute {self.value} - Not Found")
+        action_name = self.name
+        if not interp.check_builtin_action(action_name):
+            interp.rt_error(f"Cannot execute {action_name} - Not Found")
             return None
-        func = live_actions[self.value]
+        func = live_actions[action_name]
         args = inspect.getfullargspec(func)
         self.do_auto_conversions(args, param_list)
         args = args[0] + args[4]
-        hook = scope.parent._h
 
         action_manager = JsOrc.get("action_manager", ActionManager)
         action_manager.pre_action_call_hook()
@@ -91,7 +94,17 @@ class Action(Item):
                 )
                 raise
         t = time.time() - ts
-
-        action_manager.post_action_call_hook(self.value, t)
-
+        action_manager.post_action_call_hook(action_name, t)
         return result
+
+    def do_auto_conversions(self, args, params):
+        """
+        Automatically make conversions for jac to internal, e.g., list to jac_set
+        """
+        for i in args.annotations.keys():
+            if args.annotations[i] == JacSet:
+                idx = args.args.index(i)
+                if idx < len(params["args"]):
+                    params["args"][idx] = JacSet(in_list=params["args"][idx])
+                if i in params["kwargs"]:
+                    params["kwargs"][i] = JacSet(in_list=params["kwargs"][i])