jaseci 1.4.2.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

jaseci/prim/obj_mixins.py

@@ -1,235 +0,0 @@
-"""
-Jaseci object mixins
-
-Various mixins to define properties of Jaseci objects
-"""
-from jaseci.utils.id_list import IdList
-from jaseci.utils.utils import logger
-import uuid
-
-
-class Anchored:
-    """Utility class for objects that hold anchor values"""
-
-    arch_map = {}
-
-    def __init__(self):
-        self.context = {}
-
-    def get_architype(self):
-        arch = self.get_arch_from_cache()  # Optimization
-        if arch and id(arch._h) == id(self._h):
-            return arch
-        arch = (
-            self._h._machine.parent().get_arch_for(self)
-            if self._h._machine is not None
-            and self._h._machine.parent() is not None
-            and self._h._machine.parent().j_type == "sentinel"
-            else None
-        )
-        mast = self.get_master()
-        if arch is None and mast.active_snt() is not None:
-            arch = mast.active_snt().get_arch_for(self)
-        elif arch is None and self.parent() and self.parent().j_type == "sentinel":
-            arch = self.parent().get_arch_for(self)
-        self.cache_arch(arch)
-        return arch
-
-    def cache_arch(self, arch):
-        Anchored.arch_map[self.kind + self.name] = arch
-
-    def get_arch_from_cache(self):
-        if (self.kind + self.name) in Anchored.arch_map:
-            return Anchored.arch_map[self.kind + self.name]
-        return None
-
-    def flush_cache():
-        Anchored.arch_map = {}
-
-    def anchor_value(self):
-        """Returns value of anchor context object"""
-        arch = self.get_architype()
-        if arch is not None:
-            anch = arch.anchor_var
-            if anch and anch in self.context.keys():
-                return self.context[anch]
-        return None
-
-    def private_values(self):
-        """Returns value of anchor context object"""
-        arch = self.get_architype()
-        if arch is not None:
-            return arch.private_vars
-        return []
-
-    def set_context(self, ctx):
-        """Assign values to context fields of object"""
-        for i in ctx.keys():
-            if i in self.get_architype().has_vars:
-                self.context[i] = ctx[i]
-            else:
-                logger.warning(str(f"{i} not a context member of {self}"))
-        self.save()
-
-
-class Sharable:
-    """Utility class for objects that are sharable between users"""
-
-    def __init__(self, m_id, mode=None, **kwargs):
-        self.set_master(m_id)
-        self.j_access = (
-            mode
-            if mode is not None
-            else self._h.get_obj(self._m_id, self._m_id).perm_default
-            if self._h.has_obj(self._m_id)
-            else "private"
-        )
-        self.j_r_acc_ids = IdList(self)
-        self.j_rw_acc_ids = IdList(self)
-
-    @property
-    def _m_id(self) -> str:
-        return self.j_master
-
-    def set_master(self, m_id):
-        if not m_id:
-            m_id = uuid.UUID(int=0).urn
-        self.j_master = m_id
-
-    def make_public(self):
-        """Make element publically accessible"""
-        self.j_access = "public"
-        self.save()
-
-    def make_read_only(self):
-        """Make element publically readable"""
-        self.j_access = "read_only"
-        self.save()
-
-    def make_private(self):
-        """Make element private"""
-        self.j_access = "private"
-        self.save()
-
-    def is_public(self):
-        """Check if element is publically accessible"""
-        return self.j_access == "public" or self.j_master == uuid.UUID(int=0).urn
-
-    def is_read_only(self):
-        """Check if element is publically readable"""
-        return self.j_access == "read_only"
-
-    def is_readable(self):
-        """Check if element is publically readable"""
-        return self.j_access == "read_only" or self.is_public()
-
-    def is_private(self):
-        """Check if element is private"""
-        return self.j_access == "private"
-
-    def super_check(self, caller_id):
-        """Quick check if caller is super master"""
-        if not hasattr(self, "_h"):
-            return False
-        user = self._h.get_obj(caller_id, caller_id, override=True)
-        if user.j_type == "super_master":
-            return True
-        return False
-
-    def check_read_access(self, caller_id, silent=False):
-        if (
-            caller_id == self._m_id
-            or self.is_readable()
-            or caller_id in self.j_r_acc_ids
-            or caller_id in self.j_rw_acc_ids
-            or self.super_check(caller_id)
-        ):
-            return True
-        if not silent:
-            logger.error(str(f"{caller_id} does not have permission to access {self}"))
-        return False
-
-    def check_write_access(self, caller_id, silent=False):
-        if (
-            caller_id == self._m_id
-            or self.is_public()
-            or caller_id in self.j_rw_acc_ids
-            or self.super_check(caller_id)
-        ):
-            return True
-        if not silent:
-            logger.error(str(f"{caller_id} does not have permission to access {self}"))
-        return False
-
-    def give_access(self, m, read_only=True):
-        """Give access to a master (user)"""
-        if not m.is_master():
-            logger.error(f"{m} is not master!")
-            return False
-        if read_only and m.jid not in self.j_r_acc_ids:
-            self.j_r_acc_ids.add_obj(m)
-        elif m.jid not in self.j_rw_acc_ids:
-            self.j_rw_acc_ids.add_obj(m)
-        return True
-
-    def remove_access(self, m):
-        """Remove access from a master (user)"""
-        ret = False
-        if m.jid in self.j_r_acc_ids:
-            self.j_r_acc_ids.remove_obj(m)
-            ret = True
-        if m.jid in self.j_rw_acc_ids:
-            self.j_rw_acc_ids.remove_obj(m)
-            ret = True
-        return ret
-
-
-class Hookable(Sharable):
-    """Utility class for objects that are savable to DBs and other stores"""
-
-    def __init__(self, h, persist: bool = True, parent=None, **kwargs):
-        self._h = h  # hook for storing and loading to persistent store
-        self._persist = persist
-        self.j_parent = parent.jid if parent else None  # member of
-        Sharable.__init__(self, **kwargs)
-
-    def check_hooks_match(self, target, silent=False):
-        """Checks whether target object hook matches self's hook"""
-        if not self._m_id or not target._m_id:
-            return True
-        elif not silent and target._h != self._h:
-            logger.critical(
-                str(
-                    "Hook for {} does not match {}, {} != {}".format(
-                        target, self, target._h, self._h
-                    )
-                )
-            )
-        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
-        """
-        self._h.save_obj(self._m_id, self)
-
-    def destroy(self):
-        """
-        Destroys self from persistent storage
-
-        Note that the object will still exist in python until GC'd
-        """
-        self._h.destroy_obj(self._m_id, self)
-        del self
-
-    def parent(self):
-        """
-        Returns the objects for list of owners of this element
-        """
-        if self.j_parent:
-            return self._h.get_obj(self._m_id, self.j_parent)

jaseci/prim/sentinel.py

@@ -1,281 +0,0 @@
-"""
-Sentinel class for Jaseci
-
-Each sentinel has an id, name, timestamp and it's set of walkers.
-"""
-from jaseci.prim.element import Element
-from jaseci.prim.obj_mixins import Anchored
-from jaseci.utils.utils import (
-    logger,
-    ColCodes as Cc,
-    is_true,
-    perf_test_start,
-    perf_test_stop,
-)
-from jaseci.utils.id_list import IdList
-from jaseci.jac.ir.jac_code import JacCode, jac_ir_to_ast
-from jaseci.jac.interpreter.sentinel_interp import SentinelInterp
-from jaseci.prim.walker import Walker
-from jaseci.prim.architype import Architype
-
-
-class Sentinel(Element, JacCode, SentinelInterp):
-    """
-    Sentinel class for Jaseci
-
-    is_active is used to signify whether sentinel is ready to run walkers, i.e,
-    register_code succeeded
-    """
-
-    def __init__(self, *args, **kwargs):
-        self.version = None
-        self.arch_ids = IdList(self)
-        self.global_vars = {}
-        self.testcases = []
-        Element.__init__(self, *args, **kwargs)
-        JacCode.__init__(self, code_ir=None)
-        SentinelInterp.__init__(self)
-
-    def reset(self):
-        """Resets state of sentinel and unregister's code"""
-        self.version = None
-        self.global_vars = {}
-        self.testcases = []
-        self.arch_ids.destroy_all()
-        JacCode.reset(self)
-        SentinelInterp.reset(self)
-        Anchored.flush_cache()
-
-    def refresh(self):
-        super().refresh()
-        self.ir_load()
-
-    def register_code(self, text, dir="./", mode="default", opt_level=4):
-        """
-        Registers a program (set of walkers and architypes) written in Jac
-        """
-        self.reset()
-        if mode == "ir":
-            self.apply_ir(text)
-        else:
-            self.register(text, dir, opt_level=opt_level)
-        if self.is_active:
-            self.ir_load()
-        return self.is_active
-
-    def load_arch_defaults(self):
-        self.arch_ids.add_obj(
-            Architype(m_id=self._m_id, h=self._h, name="root", kind="node", parent=self)
-        )
-        self.arch_ids.add_obj(
-            Architype(
-                m_id=self._m_id, h=self._h, name="generic", kind="node", parent=self
-            )
-        )
-        self.arch_ids.add_obj(
-            Architype(
-                m_id=self._m_id, h=self._h, name="generic", kind="edge", parent=self
-            )
-        )
-
-    def ir_load(self):
-        """
-        Load walkers and architypes from IR
-        """
-        self.load_arch_defaults()
-        self.run_start(self._jac_ast)
-
-        if self.runtime_errors:
-            logger.error(str(f"{self.name}: Runtime problem processing sentinel!"))
-            self.is_active = False
-        elif not self.arch_ids:
-            logger.error(str(f"{self.name}: No walkers nor architypes created!"))
-            self.is_active = False
-        return self.is_active
-
-    def register_architype(self, code, opt_level=4):
-        """Adds an architype based on jac code"""
-        tree = self.compile_jac(
-            code, dir="./", start_rule="architype", opt_level=opt_level
-        )
-        if not tree:
-            return None
-        return self.load_architype(tree)
-
-    def spawn_architype(self, name, kind=None, caller=None, is_async=None):
-        """
-        Spawns a new architype from registered architypes and adds to
-        live walkers
-        """
-        src_arch = self.arch_ids.get_obj_by_name(name, kind=kind, silent=True)
-        if not src_arch:
-            logger.error(str(f"{self.name}: Unable to spawn {kind} architype {name}!"))
-            return None
-        src_arch.is_async = src_arch.is_async if is_async is None else is_true(is_async)
-        if caller and caller._m_id != src_arch._m_id:
-            new_arch = src_arch.duplicate()
-            new_arch.set_master(caller._m_id)
-            new_arch._jac_ast = src_arch._jac_ast
-            if new_arch._jac_ast is None:
-                new_arch.refresh()
-            return new_arch
-        else:
-            return src_arch
-
-    def run_architype(self, name, kind=None, caller=None, is_async=None):
-        """
-        Spawn, run, then destroy architype if m_id's are different
-        """
-        if caller is None:
-            caller = self
-        arch = self.spawn_architype(name, kind, caller, is_async)
-        if arch is None:
-            logger.error(
-                str(f"{self.name}: Unable to spawn architype " f"{[name, kind]}!")
-            )
-            return None
-        if arch.jid in self.arch_ids:
-            return arch.run()
-        else:
-            ret = arch.run()
-            Element.destroy(arch)
-            return ret
-
-    def get_arch_for(self, obj):
-        """Returns the architype that matches object"""
-        ret = self.arch_ids.get_obj_by_name(name=obj.name, kind=obj.kind)
-        if ret is None:
-            self.rt_subtle_error(
-                f"Unable to find architype for {obj.name}, {obj.kind}",
-                self._cur_jac_ast,
-            )
-        return ret
-
-    def run_tests(self, specific=None, profiling=False, detailed=False, silent=False):
-        """
-        Testcase schema
-        testcase = {
-            "name": kid[1].token_text() if kid[1].name == "NAME" else "",
-            "title": kid[2].token_text()
-            if kid[1].name == "NAME"
-            else kid[1].token_text(),
-            "graph_ref": None,
-            "graph_block": None,
-            "walker_ref": None,
-            "spawn_ctx": None,
-            "assert_block": None,
-            "walker_block": None,
-            "outcome": None,
-        }
-        """
-        from pprint import pformat
-        from time import time
-        import sys
-        import io
-
-        num_failed = 0
-        num_tests = 0
-        for i in self.testcases:
-            if specific is not None and i["name"] != specific:
-                continue
-            num_tests += 1
-            screen_out = [sys.stdout, sys.stderr]
-            buff_out = [io.StringIO(), io.StringIO()]
-            destroy_set = []
-            title = i["title"]
-            if i["graph_ref"]:
-                gph = self.run_architype(i["graph_ref"], kind="graph", caller=self)
-            else:
-                gph = Architype(
-                    m_id=self._m_id,
-                    h=self._h,
-                    parent=self,
-                    code_ir=jac_ir_to_ast(i["graph_block"]),
-                )
-                destroy_set.append(gph)
-                gph = gph.run()
-            if i["walker_ref"]:
-                wlk = self.run_architype(
-                    name=i["walker_ref"], kind="walker", caller=self
-                )
-            else:
-                wlk = Walker(
-                    m_id=self._m_id,
-                    h=self._h,
-                    parent=self,
-                    code_ir=jac_ir_to_ast(i["walker_block"]),
-                )
-                destroy_set.append(wlk)
-            wlk.prime(gph)
-            if i["spawn_ctx"]:
-                self.run_spawn_ctx(jac_ir_to_ast(i["spawn_ctx"]), wlk)
-
-            stime = time()
-            if profiling:
-                pr = perf_test_start()
-            try:
-                if not silent:
-                    print(f"Testing {title}: ", end="")
-                sys.stdout, sys.stderr = buff_out[0], buff_out[1]
-                wlk.run()
-                sys.stdout, sys.stderr = screen_out[0], screen_out[1]
-                if i["assert_block"]:
-                    wlk._loop_ctrl = None
-                    wlk._jac_try_mode += 1
-                    wlk.scope_and_run(
-                        jac_ir_to_ast(i["assert_block"]),
-                        run_func=wlk.run_code_block,
-                        scope_name="assert_block",
-                    )
-                    wlk._jac_try_mode -= 1
-                i["passed"] = True
-                if not silent:
-                    print(
-                        f"[{Cc.TG}PASSED{Cc.EC} in {Cc.TY}{time()-stime:.2f}s{Cc.EC}]"
-                    )
-                if detailed and not silent:
-                    print("REPORT: " + pformat(wlk.report))
-            except Exception as e:
-                sys.stdout, sys.stderr = screen_out[0], screen_out[1]
-                i["passed"] = False
-                num_failed += 1
-                if not silent:
-                    print(
-                        f"[{Cc.TR}FAILED{Cc.EC} in {Cc.TY}{time()-stime:.2f}s{Cc.EC}]"
-                    )
-                    print(f"{e}")
-            for i in destroy_set:  # FIXME: destroy set not complete
-                i.destroy()
-            if profiling:
-                print(perf_test_stop(pr))
-
-        summary = {
-            "tests": num_tests,
-            "passed": num_tests - num_failed,
-            "failed": num_failed,
-            "success": num_tests and not num_failed,
-        }
-        if detailed:
-            details = []
-            for i in self.testcases:
-                if specific is not None and i["name"] != specific:
-                    continue
-                details.append(
-                    {
-                        "test": i["title"],
-                        "passed": i["passed"],
-                        "stdout": buff_out[0].getvalue(),
-                        "stderr": buff_out[1].getvalue(),
-                    }
-                )
-            summary["details"] = details
-        return summary
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        Anchored.flush_cache()
-        for i in self.arch_ids.obj_list():
-            i.destroy()
-        super().destroy()

jaseci/prim/super_master.py

@@ -1,31 +0,0 @@
-"""
-Super master handler for each user of Jaseci, serves as main interface between
-between user and Jaseci
-"""
-
-from jaseci.extens.api.jsorc_api import JsOrcApi
-from jaseci.prim.master import Master
-from jaseci.extens.api.logger_api import LoggerApi
-from jaseci.extens.api.config_api import ConfigApi
-from jaseci.extens.api.global_api import GlobalApi
-from jaseci.extens.api.super_api import SuperApi
-from jaseci.extens.api.actions_api import ActionsApi
-from jaseci.extens.api.prometheus_api import PrometheusApi
-from jaseci.jsorc.jsorc import JsOrc
-
-
-@JsOrc.context(name="super_master")
-class SuperMaster(
-    Master,
-    LoggerApi,
-    ActionsApi,
-    ConfigApi,
-    GlobalApi,
-    SuperApi,
-    JsOrcApi,
-    PrometheusApi,
-):
-    """Master with admin APIs"""
-
-    def __init__(self, *args, **kwargs):
-        Master.__init__(self, *args, **kwargs)