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

jaseci/extens/api/jsorc_api.py

@@ -1,316 +0,0 @@
-"""
-JSORC APIs
-"""
-import json
-from json import dumps
-from time import time
-
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.jsorc.jsorc_utils import convert_yaml_manifest, ManifestType
-from jaseci.utils.utils import logger
-from jaseci.extens.svc.kube_svc import KubeService
-from jaseci.utils.file_handler import FileHandler
-from jaseci.utils.actions.actions_manager import ActionManager
-
-from jaseci.extens.api.interface import Interface
-
-
-class JsOrcApi:
-    """
-    API for managing JsOrc
-    """
-
-    @Interface.admin_api()
-    def load_yaml(
-        self,
-        files: list,
-        manifest_type: str = "DEDICATED",
-        manual_namespace: str = "default",
-    ):
-        """
-        applying list of yaml files without associating to any modules/services
-        """
-
-        try:
-            kube = JsOrc.svc("kube").poke(KubeService)
-
-            res = {}
-            for file in files:
-                file: FileHandler = self._h.get_file_handler(file)
-                file.open()
-
-                for kind, confs in kube.resolve_manifest(
-                    convert_yaml_manifest(file.buffer),
-                    ManifestType[manifest_type],
-                    manual_namespace,
-                ).items():
-                    for name, conf in confs.items():
-                        metadata: dict = conf["metadata"]
-                        kube.create(
-                            kind,
-                            metadata["name"],
-                            conf,
-                            metadata.get("namespace"),
-                        )
-                        if not res.get(kind):
-                            res[kind] = {}
-                        res[kind].update({name: conf})
-
-                file.close()
-            return res
-        except Exception:
-            logger.exception("Error loading yaml!")
-            return {"message": "load_yaml is not supported on non automated JsOrc!"}
-
-    @Interface.admin_api(cli_args=["service"])
-    def apply_yaml(self, service: str, file: list, unsafe_paraphrase: str = ""):
-        """
-        apply manifest yaml to specific service
-        """
-        svc = JsOrc.svc(service)
-
-        new_config = {}
-
-        config_version = str(time())
-
-        file: FileHandler = self._h.get_file_handler(file[0])
-        file.open()
-
-        for kind, confs in convert_yaml_manifest(file.buffer).items():
-            for name, conf in confs.items():
-                metadata = conf["metadata"]
-                labels: dict = metadata.get("labels", {})
-                if not labels.get("config_version"):
-                    labels["config_version"] = config_version
-                    metadata["labels"] = labels
-
-                if not new_config.get(kind):
-                    new_config[kind] = {}
-                new_config[kind].update({name: conf})
-
-        file.close()
-
-        if unsafe_paraphrase == JsOrc.settings("UNSAFE_PARAPHRASE"):
-            new_config["__UNSAFE_PARAPHRASE__"] = unsafe_paraphrase
-
-        self._h.save_glob(svc.source["manifest"], dumps(new_config))
-        JsOrc.add_regeneration_queue(service)
-
-        return new_config
-
-    @Interface.admin_api()
-    def jsorc_refresh(self):
-        """
-        refreshing jsorc's config.
-        """
-
-        JsOrc.configure()
-
-        return {
-            "running_interval": JsOrc._running_interval,
-            "config": JsOrc._config,
-        }
-
-    @Interface.admin_api(cli_args=["name"])
-    def service_info(self, name: str):
-        """
-        getting service's info.
-        """
-
-        # will throw exception if not existing
-        return JsOrc.svc(name).info()
-
-    @Interface.admin_api(cli_args=["name"])
-    def service_config_set(self, name: str, config: dict):
-        """
-        Set a service config
-        """
-        return JsOrc.svc_conf_set(name, config, self._h)
-
-    @Interface.admin_api(cli_args=["name"])
-    def service_refresh(self, name: str):
-        """
-        refreshing service's config. If JsOrc is not automated, service will restart else JsOrc will handle the rest
-        """
-
-        # will throw exception if not existing
-        JsOrc.svc_reset(name)
-
-        return {"success": True}
-
-    @Interface.admin_api(cli_args=["name"])
-    def service_call(self, svc: str, attrs: list = []):
-        """
-        temporary api for retreiving/calling attributes of specific instance.
-        """
-
-        svc = JsOrc.svc(svc)
-
-        if not svc:
-            return "Service (svc) field is required!"
-
-        if not attrs:
-            return "Attributes (attrs) field is required!"
-
-        res = svc
-        for at in attrs:
-            attr = at.get("attr", False)
-            if attr:
-                res = getattr(res, attr)
-
-            if at.get("callable", False):
-                args = at.get("args", [])
-                kwargs = at.get("kwargs", {})
-                res = res(*args, **kwargs)
-
-        try:
-            # test if json serializable
-            json.dumps(res)
-            return res
-        except Exception:
-            return {"error": f"Not JSON Serializable! class {res.__class__.__name__}"}
-
-    @Interface.admin_api(cli_args=["name"])
-    def jsorc_actions_load(self, name: str, mode: str):
-        """
-        Load an action as remote or local mode through JSORC.
-        JSORC will load the corresponding module or start a microservice if needed.
-        Return the current status of the action.
-        """
-        action_manager = JsOrc.get("action_manager", ActionManager)
-        action_manager.load_actions(name, mode)
-        status = action_manager.get_actions_status(name)
-
-        return {"success": True, "action_status": status}
-
-    @Interface.admin_api(cli_args=["name"])
-    def jsorc_actions_status(self, name: str):
-        """
-        Get the current status of an action
-        """
-        status = JsOrc.get("action_manager", ActionManager).get_actions_status(name)
-        return {"success": True, "action_status": status}
-
-    @Interface.admin_api(cli_args=["name"])
-    def jsorc_actions_unload(
-        self, name: str, mode: str = "auto", retire_svc: bool = True
-    ):
-        """
-        Unload an action through JSORC.
-        If retire_svc is set to True (true by default), it will also retire the corresponding microservice.
-        """
-        res = JsOrc.get("action_manager", ActionManager).unload_actions(
-            name, mode, retire_svc
-        )
-        return {"success": res[0], "message": res[1]}
-
-    @Interface.admin_api(cli_args=["config", "name"])
-    def jsorc_actions_config(self, config: str, name: str):
-        """
-        Loading the config of an action module
-        config: name of the ai kit package (e.g. jac_nlp.config, jac_vision.config)
-        name: name of the action module (e.g. use_enc, bi_enc)
-        """
-        res = JsOrc.get("action_manager", ActionManager).load_action_config(
-            config, name
-        )
-        return {"success": res}
-
-    @Interface.admin_api()
-    def jsorc_trackact_start(self):
-        """ "
-        Instruct JSORC to start tracking any changes in actions state
-        """
-        JsOrc.get("action_manager", ActionManager).actions_tracking_start()
-        return {"success": True}
-
-    @Interface.admin_api()
-    def jsorc_trackact_stop(self):
-        """ "
-        Instruct JSORC to start tracking any changes in actions state
-        """
-        return JsOrc.get("action_manager", ActionManager).actions_tracking_stop()
-
-    @Interface.admin_api()
-    def jsorc_benchmark_start(self):
-        """
-        Tell JSORC to start collecting request performance metrics
-        """
-        JsOrc.get("action_manager", ActionManager).benchmark_start()
-        return {"success": True}
-
-    @Interface.admin_api()
-    def jsorc_benchmark_report(self):
-        """
-        Report the collected request performance metrics of the currently ongoing benchmark
-        """
-        return JsOrc.get("action_manager", ActionManager).benchmark_report()
-
-    @Interface.admin_api()
-    def jsorc_benchmark_stop(self, report: bool = True):
-        """
-        End the benchmark period and report performance metrics
-        """
-        return JsOrc.get("action_manager", ActionManager).benchmark_stop(report)
-
-    @Interface.admin_api()
-    def jsorc_tracksys_start(self):
-        """
-        Ask JSORC to start tracking the state of the system as observed by JSORC on every interval.
-        """
-        JsOrc.get("action_manager", ActionManager).state_tracking_start()
-        return {"success": True}
-
-    @Interface.admin_api()
-    def jsorc_tracksys_report(self):
-        """
-        Report the tracked system states so far
-        """
-        return JsOrc.get("action_manager", ActionManager).state_tracking_report()
-
-    @Interface.admin_api()
-    def jsorc_tracksys_stop(self):
-        """
-        Stop state tracking for JSORC
-        """
-        return JsOrc.get("action_manager", ActionManager).state_tracking_stop()
-
-    @Interface.admin_api()
-    def jsorc_actionpolicy_set(self, policy_name: str, policy_params: dict = {}):
-        """
-        Set an action optimization policy for JSORC
-        """
-        res = JsOrc.get("action_manager", ActionManager).set_action_policy(
-            policy_name, policy_params
-        )
-        if res is True:
-            return {
-                "success": True,
-                "message": f"Action optimization policy configured as {policy_name} with params {policy_params}",
-            }
-        else:
-            return {"success": False, "message": res}
-
-    @Interface.admin_api()
-    def jsorc_actionpolicy_get(self):
-        """
-        Get the current active action optimization policy
-        """
-        policy = JsOrc.get("action_manager", ActionManager).get_action_policy()
-        return {"success": True, "policy": policy}
-
-    @Interface.admin_api()
-    def jsorc_loadtest(
-        self,
-        test: str,
-        experiment: str = "",
-        mem: int = 0,
-        policy: str = "all_local",
-        experiment_duration: int = 180,
-        eval_phase: int = 10,
-        perf_phase: int = 100,
-    ):
-        """
-        load test API. overwritten in jaseci_serv
-        """
-        pass

jaseci/extens/api/logger_api.py

@@ -1,89 +0,0 @@
-"""
-Logger api as a mixin
-"""
-import re
-from jaseci.extens.api.interface import Interface
-from jaseci.utils.log_utils import parse_logs
-from jaseci.utils.utils import logger, app_logger, logs
-from jaseci.utils.utils import connect_logger_handler
-from logging.handlers import HTTPHandler
-
-
-class LoggerApi:
-    """
-    APIs for Jaseci Logging configuration
-    """
-
-    @Interface.admin_api(cli_args=["host"])
-    def logger_http_connect(self, host: str, port: int, url: str, log: str = "all"):
-        """
-        Connects internal logging to http(s) (log msgs sent via POSTs)
-        Valid log params: {sys, app, all }
-        """
-        num = 0
-        if log == "sys" or log == "all":
-            connect_logger_handler(
-                logger, HTTPHandler(host=f"{host}:{port}", url=url, method="POST")
-            )
-            num += 1
-        if log == "app" or log == "all":
-            connect_logger_handler(
-                app_logger, HTTPHandler(host=f"{host}:{port}", url=url, method="POST")
-            )
-            num += 1
-        return [f"{num} http handlers added!"]
-
-    @Interface.admin_api()
-    def logger_http_clear(self, log: str = "all"):
-        """
-        Connects internal logging to http(s) (log msgs sent via POSTs)
-        Valid log params: {sys, app, all }
-        """
-        num = 0
-        if log == "sys" or log == "all":
-            for i in logger.handlers:
-                if i.__class__.__name__ == "HTTPHandler":
-                    logger.removeHandler(i)
-                    num += 1
-        if log == "app" or log == "all":
-            for i in app_logger.handlers:
-                if i.__class__.__name__ == "HTTPHandler":
-                    app_logger.removeHandler(i)
-                    num += 1
-        return [f"{num} http handlers removed!"]
-
-    @Interface.admin_api()
-    def logger_get(self, search: str = "", level: str = None):
-        """Get logs across loggers"""
-        result = []
-        for log in logs.getvalue().splitlines():
-            # skip logs produced by calling this endpoint
-            if re.search("Incoming call to logger_get", log):
-                continue
-
-            if search:
-                if re.search(search, log):
-                    result.append(log)
-                continue
-
-            result.append(log)
-
-        result = parse_logs(result)
-
-        if level:
-            result = list(filter(lambda item: level and item["level"] == level, result))
-
-        return result
-
-    @Interface.admin_api()
-    def logger_list(self):
-        """
-        Check active loggers
-        """
-        core = []
-        app = []
-        for i in logger.handlers:
-            core.append(str(type(i)))
-        for i in app_logger.handlers:
-            app.append(str(type(i)))
-        return {"core": core, "app": app}

jaseci/extens/api/master_api.py

@@ -1,133 +0,0 @@
-"""
-Master api as a mixin
-"""
-from jaseci.extens.api.interface import Interface
-from jaseci.utils.id_list import IdList
-import uuid
-
-
-class MasterApi:
-    """
-    Master APIs for users creating and managing groups of sub users
-
-    These APIs
-    """
-
-    def __init__(self, head_master):
-        self.caller = None
-        self.head_master_id = head_master
-        self.sub_master_ids = IdList(self)
-
-    @Interface.private_api(cli_args=["name"])
-    def master_create(
-        self,
-        name: str,
-        password: str = "",
-        global_init: str = "",
-        global_init_ctx: dict = {},
-        other_fields: dict = {},
-    ):
-        """
-        Create a master instance and return root node master object
-
-        other_fields used for additional feilds for overloaded interfaces
-        (i.e., Dango interface)
-        """
-        if self.sub_master_ids.has_obj_by_name(name):
-            return {"response": f"{name} already exists", "success": False}
-        ret = {}
-        mast = self.user_creator(name, password, other_fields)
-        ret["user"] = mast.serialize()
-        if len(global_init):
-            ret["global_init"] = self.user_global_init(
-                mast, global_init, global_init_ctx
-            )
-        self.take_ownership(mast)
-        ret["success"] = True
-        return ret
-
-    @Interface.private_api(cli_args=["name"])
-    def master_get(self, name: str, mode: str = "default", detailed: bool = False):
-        """
-        Return the content of the master with mode
-        Valid modes: {default, }
-        """
-        mas = self.sub_master_ids.get_obj_by_name(name)
-        if not mas:
-            return {"response": f"{name} not found"}
-        else:
-            return mas.serialize(detailed=detailed)
-
-    @Interface.private_api()
-    def master_list(self, detailed: bool = False):
-        """
-        Provide complete list of all master objects (list of root node objects)
-        """
-        masts = []
-        for i in self.sub_master_ids.obj_list():
-            masts.append(i.serialize(detailed=detailed))
-        return masts
-
-    @Interface.private_api(cli_args=["name"])
-    def master_active_set(self, name: str):
-        """
-        Sets the default master master should use
-        NOTE: Specail handler included in general_interface_to_api
-        """
-        mas = self.sub_master_ids.get_obj_by_name(name)
-        if not mas:
-            return {"response": f"{name} not found"}
-        self.caller = mas.jid
-        return {"response": f"You are now {mas.name}"}
-
-    @Interface.private_api()
-    def master_active_unset(self):
-        """
-        Unsets the default sentinel master should use
-        """
-        self.caller = None
-        return {"response": f"You are now {self.name}"}
-
-    @Interface.private_api()
-    def master_active_get(self, detailed: bool = False):
-        """
-        Returns the default master master is using
-        """
-        if self.caller:
-            return self._h.get_obj(self._m_id, self.caller).serialize(detailed=detailed)
-        else:
-            return self.serialize(detailed=detailed)
-
-    @Interface.private_api()
-    def master_self(self, detailed: bool = False):
-        """
-        Returns the masters object
-        """
-        return self.serialize(detailed=detailed)
-
-    @Interface.private_api(cli_args=["name"])
-    def master_delete(self, name: str):
-        """
-        Permanently delete master with given id
-        """
-        if not self.sub_master_ids.has_obj_by_name(name):
-            return {"response": f"{name} not found", "success": False}
-        self.sub_master_ids.destroy_obj_by_name(name)
-        self.user_destroyer(name)
-        return {"response": f"{name} has been destroyed", "success": True}
-
-    def take_ownership(self, m):
-        """
-        Assumes owenership over another master
-        """
-        m.head_master_id = self.jid
-        m.give_access(self)
-        m.save()
-        self.sub_master_ids.add_obj(m)
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        for i in self.sub_master_ids.obj_list():
-            i.destroy()

jaseci/extens/api/object_api.py

@@ -1,101 +0,0 @@
-"""
-Object api as a mixin
-"""
-from jaseci.extens.api.interface import Interface
-from jaseci.prim.element import Element
-
-
-class ObjectApi:
-    """Object APIs for generalized operations on Jaseci objects
-
-    ...
-    """
-
-    def __init__(self):
-        self.perm_default = "private"
-        self._valid_perms = ["public", "private", "read_only"]
-
-    @Interface.private_api(cli_args=["name"])
-    def global_get(self, name: str):
-        """
-        Get a global var
-        """
-        return {"value": self._h.get_glob(name)}
-
-    @Interface.private_api(cli_args=["obj"])
-    def object_get(self, obj: Element, depth: int = 0, detailed: bool = False):
-        """Returns object details for any Jaseci object."""
-        ret = obj.serialize(deep=depth, detailed=detailed)
-        return ret
-
-    @Interface.private_api(cli_args=["obj"])
-    def object_set(
-        self, obj: Element, ctx: dict, depth: int = 0, detailed: bool = False
-    ):
-        """Update a field in an object."""
-        if "jid" in ctx:
-            del ctx["jid"]
-        for i in ctx.keys():
-            if i in dir(obj) and not callable(getattr(obj, i)):
-                setattr(obj, i, ctx[i])
-        return obj.serialize(deep=depth, detailed=detailed)
-
-    @Interface.private_api(cli_args=["obj"])
-    def object_perms_get(self, obj: Element):
-        """Returns object access mode for any Jaseci object."""
-        return {"access": obj.j_access}
-
-    @Interface.private_api(cli_args=["obj"])
-    def object_perms_set(self, obj: Element, mode: str):
-        """Sets object access mode for any Jaseci object."""
-        ret = {}
-        if mode not in self._valid_perms:
-            ret["success"] = False
-            ret["response"] = f"{mode} not valid, must be in {self._valid_perms}"
-        else:
-            getattr(obj, "make_" + mode)()
-            ret["success"] = True
-            ret["response"] = f"{obj} set to {mode}"
-        return ret
-
-    @Interface.private_api(cli_args=["mode"])
-    def object_perms_default(self, mode: str):
-        """Sets object access mode for any Jaseci object."""
-        ret = {}
-        if mode not in self._valid_perms:
-            ret["success"] = False
-            ret["response"] = f"{mode} not valid, must be in {self._valid_perms}"
-        else:
-            self.perm_default = mode
-            ret["success"] = True
-            ret["response"] = f"Default access for future objects set to {mode}"
-        return ret
-
-    @Interface.private_api(cli_args=["obj"])
-    def object_perms_grant(self, obj: Element, mast: Element, read_only: bool = False):
-        """Grants another user permissions to access a Jaseci object."""
-        granted = obj.give_access(mast, read_only=read_only)
-        ret = {"success": granted}
-        if granted:
-            ret["response"] = f"Access to {obj} granted to {mast}"
-        else:
-            ret["response"] = f"Cannot grant {mast} access to {obj}"
-        return ret
-
-    @Interface.private_api(cli_args=["obj"])
-    def object_perms_revoke(self, obj: Element, mast: Element):
-        """Remove permissions for user to access a Jaseci object."""
-        revoked = obj.remove_access(mast)
-        ret = {"success": revoked}
-        if revoked:
-            ret["response"] = f"Access to {obj} revoked from {mast}"
-        else:
-            ret["response"] = f"{mast} did not have access to {obj}"
-        return ret
-
-    @Interface.public_api()
-    def info(self):
-        """Provide information about this instance of Jaseci"""
-        from jaseci import __version__, __creator__, __url__
-
-        return {"Version": __version__, "Creator": __creator__, "URL": __url__}