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

jaseci/extens/api/graph_api.py

@@ -1,168 +0,0 @@
-"""
-Graph api functions as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.utils.id_list import IdList
-from jaseci.prim.graph import Graph
-from jaseci.prim.node import Node
-import uuid
-
-
-class GraphApi:
-    """
-    Graph APIs
-    """
-
-    def __init__(self):
-        self.active_gph_id = None
-        self.graph_ids = IdList(self)
-
-    @Interface.private_api()
-    def graph_create(self, set_active: bool = True):
-        """
-        Create a graph instance and return root node graph object
-        """
-        gph = Graph(m_id=self._m_id, h=self._h)
-        self.graph_ids.add_obj(gph)
-        if set_active:
-            self.graph_active_set(gph)
-        return gph.serialize()
-
-    @Interface.private_api()
-    def graph_get(
-        self,
-        nd: Node = None,
-        mode: str = "default",
-        detailed: bool = False,
-        depth: int = 0,
-    ):
-        """
-        Return the content of the graph with mode
-        Valid modes: {default, dot, }
-        """
-        if mode == "dot":
-            return nd.traversing_dot_str(detailed, depth)
-
-        nodes, edges = nd.get_all_architypes(depth)
-        items = []
-        for i in nodes.values():
-            items.append(i.serialize(detailed=detailed))
-        for i in edges.values():
-            items.append(i.serialize(detailed=detailed))
-        return items
-
-    @Interface.private_api()
-    def graph_list(self, detailed: bool = False):
-        """
-        Provide complete list of all graph objects (list of root node objects)
-        """
-        gphs = []
-        for i in self.graph_ids.obj_list():
-            gphs.append(i.serialize(detailed=detailed))
-        return gphs
-
-    @Interface.private_api(cli_args=["gph"])
-    def graph_active_set(self, gph: Graph):
-        """
-        Sets the default graph master should use
-        """
-        self.active_gph_id = gph.jid
-        self.alias_register("active:graph", gph.jid)
-        return [f"Graph {gph.id} set as default"]
-
-    @Interface.private_api()
-    def graph_active_unset(self):
-        """
-        Unsets the default sentinel master should use
-        """
-        self.active_gph_id = None
-        self.alias_delete("active:graph")
-        return ["Default graph unset"]
-
-    @Interface.private_api()
-    def graph_active_get(self, detailed: bool = False):
-        """
-        Returns the default graph master is using
-        """
-        if self.active_gph_id:
-            default = self._h.get_obj(self._m_id, self.active_gph_id)
-            return default.serialize(detailed=detailed)
-        else:
-            return {"success": False, "response": "No default graph is selected!"}
-
-    @Interface.private_api(cli_args=["gph"])
-    def graph_delete(self, gph: Graph):
-        """
-        Permanently delete graph with given id
-        """
-        if self.active_gph_id == gph.jid:
-            self.graph_active_unset()
-        self.graph_ids.destroy_obj(gph)
-        return [f"Graph {gph.id} successfully deleted"]
-
-    @Interface.private_api(cli_args=["nd"])
-    def graph_node_get(self, nd: Node, keys: list = []):
-        """
-        Returns value a given node
-        """
-        ret = {}
-        nd_ctx = nd.serialize(detailed=True)["context"]
-        for i in nd_ctx.keys():
-            if not len(keys) or i in keys:
-                ret[i] = nd_ctx[i]
-        return ret
-
-    @Interface.private_api(cli_args=["nd"])
-    def graph_node_view(
-        self,
-        nd: Node = None,
-        detailed: bool = False,
-        show_edges: bool = False,
-        node_type: str = "",
-        edge_type: str = "",
-    ):
-        """
-        Returns value a given node
-        """
-        ret = [nd.serialize(detailed=detailed)]
-        for i in nd.attached_nodes():
-            if not len(node_type) or i.name == node_type:
-                edges = [
-                    en
-                    for en in nd.attached_edges(i)
-                    if not len(edge_type) or en.name == edge_type
-                ]
-                if len(edges):
-                    ret.append(i.serialize(detailed=detailed))
-                    if show_edges:
-                        for j in edges:
-                            ret.append(j.serialize(detailed=detailed))
-        return ret
-
-    @Interface.private_api(cli_args=["nd"])
-    def graph_node_set(self, nd: Node, ctx: dict):
-        """
-        Assigns values to member variables of a given node using ctx object
-        """
-        nd.set_context(ctx=ctx)
-        return nd.serialize()
-
-    @Interface.cli_api(cli_args=["file"])
-    def graph_walk(self, nd: Node = None):
-        cmd = ""
-        while cmd not in ["quit", "q", "exit"]:
-            print(
-                "location - " + ":".join([nd.kind, nd.name, nd.jid.strip("urn:uuid:")])
-            )
-            cmd = input("graph_walk_mode > ")
-
-    def active_gph(self):
-        return self._h.get_obj(self._m_id, self.active_gph_id)
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        for i in self.graph_ids.obj_list():
-            i.destroy()

jaseci/extens/api/health_api.py

@@ -1,21 +0,0 @@
-"""
-Health APIs
-"""
-
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.extens.api.interface import Interface
-
-
-class HealthApi:
-    """
-    API for readiness probe
-    """
-
-    @Interface.public_api(allowed_methods=["get"])
-    def health(self):
-        """
-        readiness probe
-        """
-        # to update
-        # we might need to return some other information here
-        return JsOrc.__running__

jaseci/extens/api/interface.py

@@ -1,269 +0,0 @@
-"""
-General master interface engine for client interfaces as mixin
-"""
-
-from inspect import signature, getdoc
-from jaseci.utils.utils import logger, is_jsonable, is_true, exc_stack_as_str_list
-from jaseci.prim.element import Element
-from jaseci.prim.walker import Walker
-import json
-
-
-class Interface:
-    """
-    General master interface engine
-    """
-
-    _public_api = []
-    _private_api = []
-    _admin_api = []
-    _cli_api = []
-
-    def __init__(self):
-        """
-        self._pub_committer is set by api implementaiton if intent
-        is to commit changes enacted by public call
-        """
-        self._pub_committer = None
-
-    def assimilate_api(
-        api_list,
-        func,
-        cmd_group=None,
-        cli_args=None,
-        url_args=None,
-        allowed_methods=None,
-    ):
-        cmd_group = func.__name__.split("_") if cmd_group is None else cmd_group
-        api_list.append(
-            {
-                "fname": func.__name__,
-                "sig": signature(func),
-                "doc": getdoc(func),
-                "groups": cmd_group,
-                "cli_args": cli_args if cli_args is not None else [],
-                "url_args": url_args if url_args is not None else [],
-                "allowed_methods": allowed_methods,
-            }
-        )
-        return func
-
-    def public_api(cmd_group=None, cli_args=None, url_args=None, allowed_methods=None):
-        def decorator_func(func):
-            return Interface.assimilate_api(
-                Interface._public_api,
-                func,
-                cmd_group,
-                cli_args,
-                url_args,
-                allowed_methods,
-            )
-
-        return decorator_func
-
-    def private_api(cmd_group=None, cli_args=None, url_args=None, allowed_methods=None):
-        def decorator_func(func):
-            return Interface.assimilate_api(
-                Interface._private_api,
-                func,
-                cmd_group,
-                cli_args,
-                url_args,
-                allowed_methods,
-            )
-
-        return decorator_func
-
-    def admin_api(cmd_group=None, cli_args=None, url_args=None, allowed_methods=None):
-        def decorator_func(func):
-            return Interface.assimilate_api(
-                Interface._admin_api,
-                func,
-                cmd_group,
-                cli_args,
-                url_args,
-                allowed_methods,
-            )
-
-        return decorator_func
-
-    def cli_api(cmd_group=None, cli_args=None):
-        def decorator_func(func):
-            return Interface.assimilate_api(
-                Interface._cli_api, func, cmd_group, cli_args
-            )
-
-        return decorator_func
-
-    def all_apis(self, with_cli_only=False):
-        ret = Interface._public_api + Interface._private_api + Interface._admin_api
-        if with_cli_only:
-            return ret + Interface._cli_api
-        return ret
-
-    assimilate_api = staticmethod(assimilate_api)
-    public_api = staticmethod(public_api)
-    private_api = staticmethod(private_api)
-    admin_api = staticmethod(admin_api)
-    cli_api = staticmethod(cli_api)
-
-    def provide_internal_default(self, param):
-        """
-        Applies internal defaults for sentinel and graphs
-        """
-        if param == "snt" and self.active_snt_id:
-            if self.active_snt_id == "global":
-                glob_id = self._h.get_glob("GLOB_SENTINEL")
-                if not glob_id:
-                    return self.interface_error("No global sentinel is available!")
-                else:
-                    return glob_id
-            return self.active_snt_id
-        if param == "gph" or param == "nd":
-            return (
-                self.active_gph_id
-                if self.active_gph_id
-                else self.interface_error("No default graph node available!")
-            )
-        return None
-
-    def interface_error(self, err, stack=None):
-        """Standard error output to logger and api response"""
-        logger.error(err)
-        ret = {"response": err, "success": False, "errors": [err]}
-        if stack:
-            ret["stack_trace"] = stack
-        return ret
-
-    def general_interface_to_api(self, params, api_name):
-        """
-        A mapper utility to interface to master class
-        Assumptions:
-            params is a dictionary of parameter names and values in UUID
-            api_name is the name of the api being mapped to
-        """
-        param_map = {}
-        if (
-            api_name.startswith("master_active")
-            or api_name.startswith("master_become")
-            or api_name.startswith("master_unbecome")
-        ):
-            _caller = self
-        elif self.caller:
-            _caller = self._h.get_obj(self._m_id, self.caller)
-        else:
-            _caller = self
-        if not hasattr(_caller, api_name):
-            return self.interface_error(f"{api_name} not a valid API")
-        func_sig = signature(getattr(_caller, api_name))
-        for i in func_sig.parameters.keys():
-            if i == "self":
-                continue
-            p_name = i
-            p_type = func_sig.parameters[i].annotation
-            p_default = func_sig.parameters[i].default
-            val = p_default if p_default is not func_sig.parameters[i].empty else None
-            if p_name in params.keys():
-                val = params[p_name]
-            if val is None:  # Used to patch defaults
-                val = _caller.provide_internal_default(p_name)
-                if val is not None and "errors" in val:
-                    return val
-            if p_type == dict and isinstance(val, str):
-                if not len(val):
-                    val = {}
-                else:
-                    val = json.loads(val)
-            if str(val) in _caller.alias_map.keys():
-                val = _caller.alias_map[val]
-            if issubclass(p_type, Element):
-                if val is None:
-                    break
-                val = _caller._h.get_obj(_caller._m_id, val)
-                if isinstance(val, p_type):
-                    param_map[i] = self.sync_constraints(val, params)
-                else:
-                    return self.interface_error(f"{type(val)} is not {p_type}")
-            else:  # TODO: Can do type checks here too
-                param_map[i] = val
-
-            if p_default and param_map[i] is None:
-                return self.interface_error(f"Invalid API args - {params}")
-        try:
-            ret = getattr(_caller, api_name)(**param_map)
-        except Exception as e:
-            return self.interface_error(
-                f"Internal Exception: {e}", stack=exc_stack_as_str_list()
-            )
-        if not is_jsonable(ret):
-            return self.interface_error(f"Non-JSON API ret {type(ret)}: {ret}")
-        return ret
-
-    def public_interface_to_api(self, params, api_name):
-        """
-        A mapper utility to interface to public
-        Assumptions:
-            params is a dictionary of parameter names and values in UUID
-            api_name is the name of the api being mapped to
-        """
-        param_map = {}
-        if not hasattr(self, api_name):
-            return self.interface_error(f"{api_name} not a valid API")
-        func_sig = signature(getattr(self, api_name))
-        for i in func_sig.parameters.keys():
-            if i == "self":
-                continue
-            p_name = i
-            p_type = func_sig.parameters[i].annotation
-            p_default = func_sig.parameters[i].default
-            val = p_default if p_default is not func_sig.parameters[i].empty else None
-            if p_name in params.keys():
-                val = params[p_name]
-            if p_type == dict and isinstance(val, str):
-                if not len(val):
-                    val = {}
-                else:
-                    val = json.loads(val)
-            if issubclass(p_type, Element):
-                if val is None:
-                    return self.interface_error(
-                        f"No {p_type} value for {p_name} provided!"
-                    )
-                val = self._h.get_obj("override", val, override=True)
-                self.seek_committer(val)
-                if isinstance(val, p_type):
-                    param_map[i] = self.sync_constraints(val, params)
-                else:
-                    return self.interface_error(f"{type(val)} is not {p_type}")
-            else:  # TODO: Can do type checks here too
-                param_map[i] = val
-
-            if param_map[i] is None:
-                return self.interface_error(f"Invalid API parameter set - {params}")
-        try:
-            ret = getattr(self, api_name)(**param_map)
-        except Exception as e:
-            return self.interface_error(
-                f"Internal Exception: {e}", stack=exc_stack_as_str_list()
-            )
-        if not is_jsonable(ret):
-            return self.interface_error(
-                str(f"API returns non json object {type(ret)}: {ret}")
-            )
-        return ret
-
-    # future constraints other than `async` should be add here
-    def sync_constraints(self, obj, params):
-        if isinstance(obj, Walker):
-            obj.is_async = is_true(params.get("is_async", obj.is_async))
-
-        return obj
-
-    def seek_committer(self, obj):
-        """Opportunistically assign a committer"""
-        if not self._pub_committer and not (obj is None):
-            self._pub_committer = obj._h.get_obj(obj._m_id, obj._m_id)
-
-    def clear_committer(self):
-        """Unset committer"""
-        self._pub_committer = None

jaseci/extens/api/jac_api.py

@@ -1,172 +0,0 @@
-"""
-Jac tools api functions as a mixin
-"""
-
-from copy import deepcopy
-import json
-import os
-
-from jaseci.extens.api.interface import Interface
-from jaseci.jsorc.jsorc import JsOrc
-
-
-class JacApi:
-    """
-    Jac tool APIs
-    """
-
-    @Interface.cli_api(cli_args=["file"])
-    def jac_build(self, file: str, out: str = "", opt_level: int = 4):
-        """
-        Command line tooling for building executable jac ir
-        """
-        filename, dir = self.check_for_file(file)
-        if not len(out):
-            if file.endswith(".jac"):
-                out = file.replace(".jac", ".jir")
-            else:
-                out = file + ".jir"
-        faux = self.faux_master()
-        with open(file, "r") as file:
-            ret = faux.sentinel_register(
-                code=file.read(),
-                code_dir=dir,
-                name=filename,
-                auto_run="",
-                opt_level=opt_level,
-            )
-            if "success" in ret and not ret["success"]:
-                return ret
-            with open(out, "w") as ofile:
-                jir_out = json.dumps(
-                    faux.sentinel_get(mode="ir", snt=faux.active_snt())
-                )
-                ofile.write(jir_out)
-                ret = f"Build of {out} complete!"
-
-                return ret
-
-    @Interface.cli_api(cli_args=["file"])
-    def jac_disas(self, file: str):
-        """
-        Command line tooling for print IR for both .jac code files
-        and .jir executables
-        """
-        filename, dir = self.check_for_file(file)
-        is_jir = file.endswith(".jir")
-        faux = self.faux_master()
-        with open(file, "r") as file:
-            if is_jir:
-                faux.sentinel_register(name=filename)
-                ret = faux.sentinel_set(
-                    snt=faux.active_snt(), code=file.read(), mode="ir"
-                )
-                faux.active_snt().print_ir()
-            else:
-                ret = faux.sentinel_register(
-                    code=file.read(), code_dir=dir, name=filename, auto_run=""
-                )
-                faux.active_snt().print_ir()
-            if "success" in ret and not ret["success"]:
-                return ret
-
-    @Interface.cli_api(cli_args=["file"])
-    def jac_test(
-        self,
-        file: str,
-        single: str = "",
-        profiling: bool = False,
-        detailed: bool = False,
-    ):
-        """
-        Command line tooling for running all test in both .jac code files
-        and .jir executables
-        """
-        filename, dir = self.check_for_file(file)
-        is_jir = file.endswith(".jir")
-        faux = self.faux_master()
-        with open(file, "r") as file:
-            if is_jir:
-                faux.sentinel_register(name=filename)
-                faux.sentinel_set(snt=faux.active_snt(), code=file.read(), mode="ir")
-            else:
-                ret = faux.sentinel_register(
-                    code=file.read(), code_dir=dir, name=filename, auto_run=""
-                )
-                if "success" in ret and not ret["success"]:
-                    return ret
-        return faux.sentinel_test(
-            snt=faux.active_snt(), single=single, profiling=profiling, detailed=detailed
-        )
-
-    @Interface.cli_api(cli_args=["file"])
-    def jac_run(
-        self, file: str, walk: str = "init", ctx: dict = {}, profiling: bool = False
-    ):
-        """
-        Command line tooling for running all test in both .jac code files
-        and .jir executables
-        """
-        filename, dir = self.check_for_file(file)
-        is_jir = file.endswith(".jir")
-        faux = self.faux_master()
-        with open(file, "r") as file:
-            if is_jir:
-                faux.sentinel_register(name=filename)
-                faux.sentinel_set(snt=faux.active_snt(), code=file.read(), mode="ir")
-            else:
-                ret = faux.sentinel_register(
-                    code=file.read(), code_dir=dir, name=filename, auto_run=""
-                )
-                if "success" in ret and not ret["success"]:
-                    return ret
-        return faux.walker_run(
-            name=walk,
-            snt=faux.active_snt(),
-            nd=faux.active_gph(),
-            ctx=ctx,
-            profiling=profiling,
-        )
-
-    @Interface.cli_api(cli_args=["file"])
-    def jac_dot(
-        self, file: str, walk: str = "init", ctx: dict = {}, detailed: bool = False
-    ):
-        """
-        Command line tooling for a walker then output graph in both .jac code
-        files and .jir executables
-        """
-        filename, dir = self.check_for_file(file)
-        is_jir = file.endswith(".jir")
-        faux = self.faux_master()
-        with open(file, "r") as file:
-            if is_jir:
-                faux.sentinel_register(name=filename)
-                faux.sentinel_set(snt=faux.active_snt(), code=file.read(), mode="ir")
-            else:
-                ret = faux.sentinel_register(
-                    code=file.read(), name=filename, code_dir=dir, auto_run=""
-                )
-                if "success" in ret and not ret["success"]:
-                    return ret
-        faux.walker_run(
-            name=walk,
-            snt=faux.active_snt(),
-            nd=faux.active_gph(),
-            ctx=ctx,
-            profiling=False,
-        )
-        return faux.graph_get(nd=faux.active_gph(), mode="dot", detailed=detailed)
-
-    def faux_master(self):
-        faux = JsOrc.super_master()
-        faux._h.mem["global"] = deepcopy(self._h.mem["global"])
-        return faux
-
-    def check_for_file(self, file):
-        if not os.path.isfile(file):
-            ret = "File does not exsist!"
-            return ret, ret
-        filename = os.path.basename(file)
-        dir = os.path.dirname(os.path.realpath(file))
-        return filename, dir