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

jaseci/extens/svc/task_svc.py

@@ -1,155 +0,0 @@
-from celery import Celery
-from celery.schedules import crontab
-from celery.app.trace import build_tracer
-from celery.app.control import Inspect
-from celery.backends.base import DisabledBackend
-
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.jsorc.jsorc_utils import ManifestType
-from .tasks import Queue, ScheduledWalker, ScheduledSequence
-
-#################################################
-#                   TASK APP                   #
-#################################################
-
-
-@JsOrc.service(name="task", config="TASK_CONFIG")
-class TaskService(JsOrc.CommonService):
-    ###################################################
-    #                   INITIALIZER                   #
-    ###################################################
-
-    def __init__(
-        self,
-        config: dict,
-        manifest: dict,
-        manifest_type: ManifestType = ManifestType.DEDICATED,
-        source: dict = {},
-    ):
-        self.inspect: Inspect = None
-        self.queue: Queue = None
-        self.scheduled_walker: ScheduledWalker = None
-        self.scheduled_sequence: ScheduledSequence = None
-
-        super().__init__(config, manifest, manifest_type, source)
-
-    ###################################################
-    #                     BUILDER                     #
-    ###################################################
-
-    def run(self):
-        self.app = Celery("celery")
-        self.app.conf.update(**self.config)
-
-        # -------------------- TASKS -------------------- #
-        (
-            self.queue,
-            self.scheduled_walker,
-            self.scheduled_sequence,
-        ) = self.register_tasks(Queue, ScheduledWalker, ScheduledSequence)
-
-        # ------------------ INSPECTOR ------------------ #
-
-        self.inspect = self.app.control.inspect()
-        self.ping()
-
-    def post_run(self):
-        self.spawn_daemon(
-            worker=self.app.Worker(quiet=self.quiet).start,
-            scheduler=self.app.Beat(socket_timeout=None, quiet=self.quiet).run,
-        )
-
-    def register_tasks(self, *tasks) -> tuple:
-        registered = []
-        for task in tasks:
-            task = self.app.register_task(task())
-            task.__trace__ = build_tracer(task.name, task, app=self.app)
-            registered.append(task)
-        return tuple(registered)
-
-    ###################################################
-    #              COMMON GETTER/SETTER               #
-    ###################################################
-
-    def get_by_task_id(self, task_id, wait=False, timeout=30):
-        task = self.app.AsyncResult(task_id)
-
-        if isinstance(task.backend, DisabledBackend):
-            return {
-                "status": "DISABLED",
-                "result": "result_backend is set to disabled!",
-            }
-
-        ret = {"status": task.state}
-        if task.ready():
-            ret["result"] = task.result
-        elif wait:
-            ret["status"] = "SUCCESS"
-            ret["result"] = task.get(timeout=timeout, disable_sync_subtasks=False)
-
-        return ret
-
-    def inspect_tasks(self):
-        return {
-            "scheduled": self.inspect.scheduled(),
-            "active": self.inspect.active(),
-            "reserved": self.inspect.reserved(),
-        }
-
-    def ping(self):  # will throw exception
-        self.inspect.ping()
-        self.app.AsyncResult("").result
-
-    ###################################################
-    #                     QUEUING                     #
-    ###################################################
-
-    def add_queue(self, wlk, nd, *args):
-        return self.queue.delay(wlk.jid, nd.jid, args).task_id
-
-    ###################################################
-    #                SCHEDULED QUEUING                #
-    ###################################################
-
-    def add_scheduled_queue(
-        self, queue_type: object, name: str, schedule: dict, body: dict
-    ):
-        return None
-
-    def get_scheduled_queues(
-        self,
-        limit: int = 10,
-        offset: int = 0,
-        asc: bool = True,
-        name: str = None,
-        master=False,
-    ):
-        return []
-
-    def delete_scheduled_queue(self, scheduled_queue_id: int, master):
-        return None
-
-    ###################################################
-    #                     CLEANER                     #
-    ###################################################
-
-    def failed(self, error):
-        super().failed(error)
-        self.terminate_daemon("worker", "scheduler")
-
-    # ---------------- PROXY EVENTS ----------------- #
-
-    def on_delete(self):
-        self.terminate_daemon("worker", "scheduler")
-
-    ###################################################
-    #                      UTILS                      #
-    ###################################################
-
-    def get_task_name(self, task):
-        cls = type(task)
-        module = cls.__module__
-        name = cls.__qualname__
-        if module is not None and module != "__builtin__":
-            name = module + "." + name
-        return name

jaseci/extens/svc/tasks.py

@@ -1,302 +0,0 @@
-import re
-from copy import deepcopy
-from typing import Tuple
-
-from celery import Task
-from requests import get, post
-from requests.exceptions import HTTPError
-from jaseci.jsorc.jsorc import JsOrc
-
-DEFAULT_MSG = "Skipping scheduled walker!"
-
-
-class Queue(Task):
-    def run(self, wlk: str, nd: str, args):
-        hook = JsOrc.hook()
-
-        wlk = hook.get_obj_from_store(wlk)
-        wlk._to_await = True
-
-        nd = hook.get_obj_from_store(nd)
-        resp = wlk.run(nd, *args)
-
-        # commit to cache first then db instead of `commit()` only
-        # this is to support both jsctl and jsserv
-        wlk._h.commit_all_cache_sync()
-        wlk._h.commit(True)
-
-        wlk.destroy()
-
-        return {"anchor": wlk.anchor_value(), "response": resp}
-
-
-class ScheduledWalker(Task):
-    def get_obj(self, jid):
-        return self.hook.get_obj_from_store(jid)
-
-    def run(self, mst, wlk="init", ctx: dict = {}, nd: str = None, snt: str = None):
-        self.hook = JsOrc.hook()
-
-        if mst:
-            mst = self.get_obj(mst)
-        else:
-            return f"{DEFAULT_MSG} mst (Master) is required!"
-
-        if mst is None:
-            return f"{DEFAULT_MSG} Invalid Master!"
-
-        try:
-            if not snt:
-                if mst.active_snt_id == "global":
-                    global_snt_id = self.hook.get_glob("GLOB_SENTINEL")
-                    snt = self.get_obj(global_snt_id)
-                elif mst.active_snt_id:
-                    snt = self.get_obj(mst.active_snt_id)
-            elif snt in mst.alias_map:
-                snt = self.get_obj(mst.alias_map[snt])
-            else:
-                snt = self.get_obj(snt)
-
-            if not snt:
-                return f"{DEFAULT_MSG} Invalid Sentinel!"
-
-            if not nd:
-                if mst.active_gph_id:
-                    nd = self.get_obj(mst.active_gph_id)
-            elif nd in mst.alias_map:
-                nd = self.get_obj(mst.alias_map[nd])
-            else:
-                nd = self.get_obj(nd)
-
-            if not nd:
-                return f"{DEFAULT_MSG} Invalid Node!"
-
-            resp = mst.walker_run(wlk, nd, ctx, ctx, snt, False, False)
-
-            mst._h.commit_all_cache_sync()
-            mst._h.commit(True)
-
-            return resp
-        except Exception as e:
-            return f"{DEFAULT_MSG} Error occured: {e}"
-
-
-class ScheduledSequence(Task):
-    json_escape = re.compile(r"[^a-zA-Z0-9_]")
-    internal = re.compile(r"\(([a-zA-Z0-9_\.\[\]\$\#\@\!]*?)\)")
-    full = re.compile(r"^\{\{([a-zA-Z0-9_\.\[\]\$\#\(\)\@\!]*?)\}\}$")
-    partial = re.compile(r"\{\{([a-zA-Z0-9_\.\[\]\$\#\(\)\@\!]*?)\}\}")
-
-    def get_deep_value(self, data, keys, default):
-        if len(keys) == 0:
-            return data
-
-        key = keys.pop(0)
-        t = type(data)
-
-        if t is dict and key in data:
-            return self.get_deep_value(data[key], keys, default)
-        elif t is list and key.isnumeric():
-            return self.get_deep_value(data[int(key)], keys, default)
-        else:
-            return default
-
-    def get_value(self, holder: Tuple, keys: str, default=None):
-        while self.internal.search(keys):
-            for intern in self.internal.findall(keys):
-                keys = keys.replace(
-                    "(" + intern + ")", self.get_value(holder, intern, "")
-                )
-
-        if keys:
-            keys = keys.split(".")
-            key = keys.pop(0)
-            if key == "#":
-                return self.get_deep_value(holder[0], keys, default)
-            elif key == "$":
-                t = type(holder[1])
-                if t is dict or t is list:
-                    return self.get_deep_value(holder[1], keys, default)
-                else:
-                    return holder[1]
-            elif key == "@":
-                t = type(holder[2])
-                if t is dict or t is list:
-                    return self.get_deep_value(holder[2], keys, default)
-                else:
-                    return holder[2]
-            elif key == "!":
-                return holder[3]
-        return default
-
-    def compare(self, condition, expected, actual):
-        if condition == "eq":
-            return actual == expected
-        elif condition == "ne":
-            return actual != expected
-        elif condition == "gt":
-            return actual > expected
-        elif condition == "gte":
-            return actual >= expected
-        elif condition == "lt":
-            return actual < expected
-        elif condition == "lte":
-            return actual <= expected
-        elif condition == "regex":
-            return re.compile(expected).match(actual)
-
-    def condition(self, holder: Tuple, filter):
-        for cons in filter["condition"].keys():
-            if not (filter["condition"][cons] is None) and not self.compare(
-                cons, filter["condition"][cons], self.get_value(holder, filter["by"])
-            ):
-                return False
-        return True
-
-    def or_condition(self, holder: Tuple, filter):
-        for filt in filter:
-            if "condition" in filt and self.condition(holder, filt):
-                return True
-            elif "or" in filt and self.or_condition(holder, filt["or"]):
-                return True
-            elif "and" in filt and self.and_condition(holder, filt["and"]):
-                return True
-        return False
-
-    def and_condition(self, holder: Tuple, filter):
-        for filt in filter:
-            if "condition" in filt and not self.condition(holder, filt):
-                return False
-            elif "or" in filt and not self.or_condition(holder, filt["or"]):
-                return False
-            elif "and" in filt and not self.and_condition(holder, filt["and"]):
-                return False
-        return True
-
-    def deep_replace_str(self, holder: Tuple, data, key):
-        matcher = self.full.match(data[key])
-        if matcher:
-            data[key] = self.get_value(holder, matcher.group(1))
-        else:
-            for rep in self.partial.findall(data[key]):
-                data[key] = data[key].replace(
-                    "{{" + rep + "}}", self.get_value(holder, rep, "")
-                )
-
-    def deep_replace_dict(self, holder: Tuple, data):
-        for key in data.keys():
-            if key != "__def_loop__":
-                t = type(data[key])
-                if t is str:
-                    self.deep_replace_str(holder, data, key)
-                elif t is dict:
-                    self.deep_replace_dict(holder, data[key])
-
-    def save(self, holder: Tuple, req, params):
-        if params in req:
-            holder[0][self.json_escape.sub("_", req[params])] = holder[1]
-
-    def trigger_interface(self, req: dict):
-        master = req.get("master")
-        if master is None:
-            caller = JsOrc.master()
-            trigger_type = "public"
-        else:
-            caller = JsOrc.hook().get_obj_from_store(master)
-            trigger_type = "general"
-
-        api = req.get("api")
-        body = req.get("body", {})
-        resp = getattr(caller, f"{trigger_type}_interface_to_api")(body, api)
-
-        caller._h.commit_all_cache_sync()
-        caller._h.commit(True)
-
-        return resp
-
-    def run(self, **kwargs):
-        requests = kwargs.get("requests")
-        persistence = kwargs.get("persistence", {})
-        container = kwargs.get("container", {"current": persistence})
-        index = container.get("index", "0")
-
-        if "parent_current" in container:
-            container["current"] = container["parent_current"]
-
-        for req in requests:
-            try:
-                self.deep_replace_dict(
-                    (
-                        persistence,
-                        container["current"],
-                        container.get("parent_current", {}),
-                        index,
-                    ),
-                    req,
-                )
-                self.save((persistence, req), req, "save_req_to")
-
-                method = req["method"].upper()
-
-                if method == "JAC":
-                    container["current"] = self.trigger_interface(req)
-                else:
-                    if method == "POST":
-                        response = post(
-                            req["api"],
-                            json=req.get("body", {}),
-                            headers=req.get("header", {}),
-                        )
-                    elif method == "GET":
-                        response = get(req["api"], headers=req.get("header", {}))
-                    response.raise_for_status()
-                    if "application/json" in response.headers.get("Content-Type"):
-                        container["current"] = response.json()
-                    else:
-                        container["current"] = response.text
-
-                if "__def_loop__" in req:
-                    def_loop = req["__def_loop__"]
-                    for idx, loop in enumerate(
-                        self.get_value(
-                            (persistence, container["current"]), def_loop["by"], []
-                        )
-                    ):
-                        if "filter" in def_loop and not self.and_condition(
-                            (persistence, loop), def_loop["filter"]
-                        ):
-                            continue
-                        loop_container = {"parent_current": loop, "index": str(idx)}
-                        self.run(
-                            requests=deepcopy(def_loop["requests"]),
-                            persistence=persistence,
-                            container=loop_container,
-                        )
-
-                self.save((persistence, container["current"]), req, "save_to")
-
-            except Exception as err:
-                container["current"] = (
-                    {
-                        "status": err.response.status_code,
-                        "message": err.response.reason,
-                    }
-                    if isinstance(err, HTTPError)
-                    else {
-                        "worker_error": str(err),
-                    }
-                )
-
-                self.save((persistence, container["current"]), req, "save_to")
-
-                if "ignore_error" not in req or not req["ignore_error"]:
-                    if "parent_current" in container:
-                        raise err
-                    break
-
-            if "break" in req and self.and_condition(
-                (persistence, container["current"]), req["break"]
-            ):
-                break
-
-        return persistence

jaseci/jac/interpreter/architype_interp.py

@@ -1,219 +0,0 @@
-"""
-Sentinel interpreter for jac code in AST form
-
-This interpreter should be inhereted from the class that manages state
-referenced through self.
-"""
-
-from jaseci.prim.node import Node
-from jaseci.prim.edge import Edge
-from jaseci.prim.walker import Walker
-from jaseci.jac.interpreter.interp import Interp
-from jaseci.jac.machine.jac_scope import JacScope
-from jaseci.jac.machine.jac_value import JacValue
-
-
-class ArchitypeInterp(Interp):
-    """Jac interpreter mixin for objects that will execute Jac code"""
-
-    def run_architype(self, jac_ast):
-        """
-        architype:
-            KW_NODE NAME (COLON NAME)* attr_block
-            | KW_EDGE NAME (COLON NAME)* attr_block
-            | KW_TYPE NAME struct_block
-            | KW_GRAPH NAME graph_block
-            | KW_ASYNC? KW_WALKER NAME namespaces? walker_block;
-        """
-        if jac_ast is None:  # Using defaults
-            if self.kind == "node" and self.name in ["root", "generic"]:
-                return Node(
-                    m_id=self._m_id,
-                    h=self._h,
-                    kind=self.kind,
-                    name=self.name,
-                    parent=self.parent(),
-                )
-            elif self.kind == "edge" and self.name in ["generic"]:
-                return Edge(
-                    m_id=self._m_id,
-                    h=self._h,
-                    kind=self.kind,
-                    name=self.name,
-                    parent=self.parent(),
-                )
-
-        kid = self.set_cur_ast(jac_ast)
-
-        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,
-                h=self._h,
-                kind=kid[0].token_text(),
-                name=kid[1].token_text(),
-                parent=self.parent(),
-            )
-            self.build_object_with_supers(item, kid[-1])
-        elif kid[0].name == "KW_EDGE":
-            item = Edge(
-                m_id=self._m_id,
-                h=self._h,
-                kind=kid[0].token_text(),
-                name=kid[1].token_text(),
-                parent=self.parent(),
-            )
-            self.build_object_with_supers(item, kid[-1])
-        elif kid[0].name == "KW_TYPE":
-            item = self.run_struct_block(kid[-1])
-        elif kid[0].name == "KW_GRAPH":
-            item = self.run_graph_block(kid[-1])
-        elif kid[0].name == "KW_WALKER":
-            item = Walker(
-                m_id=self._m_id,
-                h=self._h,
-                code_ir=jac_ast,
-                name=kid[1].token_text(),
-                kind=kid[0].token_text(),
-                parent=self.parent(),
-                is_async=self.is_async,
-            )
-            if kid[2].name == "namespaces":
-                item.namespaces = self.run_namespaces(jac_ast.kid[2])
-            self.build_object_with_supers(item, kid[-1])
-        elif jac_ast.name == "graph_block":  # usedi n jac tests
-            item = self.run_graph_block(jac_ast)
-        self.pop_scope()
-        return item
-
-    def run_namespaces(self, jac_ast):
-        """
-        namespaces: COLON name_list;
-        """
-        return self.run_name_list(jac_ast.kid[1])
-
-    def run_walker_block(self, jac_ast, obj):
-        """
-        walker_block:
-            LBRACE attr_stmt* walk_entry_block? (
-                statement
-                | walk_activity_block
-            )* walk_exit_block? RBRACE;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        for i in kid:
-            if i.name == "attr_stmt":
-                self.run_attr_stmt(jac_ast=i, obj=obj)
-
-    def run_attr_block(self, jac_ast, obj):
-        """
-        attr_block:
-            LBRACE (attr_stmt)* RBRACE
-            | COLON (attr_stmt)* SEMI
-            | SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        for i in kid:
-            if i.name == "attr_stmt":
-                self.run_attr_stmt(i, obj)
-
-    def run_attr_stmt(self, jac_ast, obj):
-        """
-        attr_stmt: has_stmt | can_stmt;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if kid[0].name == "has_stmt":
-            self.run_has_stmt(kid[0], obj)
-        #  Can statements in architype handled in architype load
-
-    def run_has_stmt(self, jac_ast, obj):
-        """
-        has_stmt: KW_HAS has_assign (COMMA has_assign)* SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        for i in kid:
-            if i.name == "has_assign":
-                self.run_has_assign(i, obj)
-
-    def run_has_assign(self, jac_ast, obj):
-        """
-        has_assign: KW_PRIVATE? KW_ANCHOR? (NAME | NAME EQ expression);
-        """
-        kid = self.set_cur_ast(jac_ast)
-        while kid[0].name in ["KW_PRIVATE", "KW_ANCHOR"]:
-            kid = kid[1:]
-        var_name = kid[0].token_text()
-        var_val = None  # jac's null
-        if len(kid) > 1:
-            self.run_expression(kid[2])
-            var_val = self.pop().value
-        if isinstance(obj, dict):
-            obj[var_name] = var_val
-        # Runs only once for walkers
-        elif var_name not in obj.context.keys() or obj.j_type != "walker":
-            JacValue(
-                self, ctx=obj, name=var_name, value=var_val, create_mode=True
-            ).write(kid[0], force=True)
-
-    def run_struct_block(self, jac_ast):
-        """
-        struct_block: LBRACE (has_stmt)* RBRACE | COLON has_stmt | SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        ret = {}
-        for i in kid:
-            if i.name == "has_stmt":
-                self.run_has_stmt(i, ret)
-        return ret
-
-    def run_graph_block(self, jac_ast):
-        """
-        graph_block:
-            LBRACE has_root can_block KW_SPAWN code_block RBRACE
-            | COLON has_root can_block KW_SPAWN code_block SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        root_name = self.run_has_root(kid[1])
-        try:
-            for ability in self.get_all_abilities().obj_list():
-                self._jac_scope.add_action(ability)
-
-            self.run_code_block(kid[4])
-        except Exception as e:
-            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):
-                self.rt_error(f"{root_name} is {type(obj)} not node!", kid[3])
-            return obj
-        else:
-            self.rt_error("Graph didn't produce root node!", kid[3])
-
-    def run_has_root(self, jac_ast):
-        """
-        has_root: KW_HAS KW_ANCHOR NAME SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        return kid[2].token_text()
-
-    # Helper Functions ##################
-
-    def build_object_with_supers(self, item, jac_ast):
-        for i in self.super_archs:
-            super_jac_ast = (
-                self.parent()
-                .arch_ids.get_obj_by_name(name=i, kind=item.kind)
-                .get_jac_ast()
-                .kid[-1]
-            )
-            (
-                self.run_attr_block(super_jac_ast, item)
-                if not isinstance(item, Walker)
-                else self.run_walker_block(super_jac_ast, item)
-            )
-        (
-            self.run_attr_block(jac_ast, item)
-            if not isinstance(item, Walker)
-            else self.run_walker_block(jac_ast, item)
-        )