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

jaseci/extens/api/prometheus_api.py

@@ -1,75 +0,0 @@
-"""
-Prometheus APIs
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.extens.svc.prome_svc import PrometheusService
-
-
-def prome():
-    return JsOrc.svc("prome").poke(PrometheusService)
-
-
-class PrometheusApi:
-    """
-    Prometheus APIs
-    """
-
-    @Interface.admin_api()
-    def prometheus_metrics_list(self):
-        """
-        Return list of availabel metrics
-        """
-        return prome().all_metrics()
-
-    @Interface.admin_api()
-    def prometheus_pod_list(self, namespace: str = "", exclude_prom: bool = False):
-        """
-        Return list of pods. If exclude_prom,
-        """
-        return prome().pods(namespace=namespace, exclude_prom=exclude_prom)
-
-    @Interface.admin_api()
-    def prometheus_pod_info(
-        self,
-        namespace: str = "",
-        exclude_prom: bool = False,
-        timestamp: int = 0,
-        duration: int = 0,
-    ):
-        """
-        Return pods info and metrics
-        """
-        return (
-            prome()
-            .info(
-                namespace=namespace,
-                exclude_prom=exclude_prom,
-                timestamp=timestamp,
-                duration=duration,
-            )
-            .pod
-        )
-
-    @Interface.admin_api()
-    def prometheus_node_info(
-        self,
-        namespace: str = "",
-        exclude_prom: bool = False,
-        timestamp: int = 0,
-        duration: int = 0,
-    ):
-        """
-        Return pods info and metrics
-        """
-        return (
-            prome()
-            .info(
-                namespace=namespace,
-                exclude_prom=exclude_prom,
-                timestamp=timestamp,
-                duration=duration,
-            )
-            .node
-        )

jaseci/extens/api/queue_api.py

@@ -1,141 +0,0 @@
-"""
-Queue api functions as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.extens.svc.task_svc import TaskService
-
-
-class QueueApi:
-    """
-    Queue APIs
-
-    APIs used for celery configuration and monitoring
-    """
-
-    @Interface.private_api(allowed_methods=["get"])
-    def walker_queue_check(self, task_id: str = ""):
-        """
-        Monitor Queues. Check the task if it's still
-            pending, running or already have the result
-        """
-        task = JsOrc.svc("task", TaskService)
-        if not task.is_running():
-            return "Task hook is not yet initialized!"
-
-        if not task_id:
-            return task.inspect_tasks()
-        else:
-            return task.get_by_task_id(task_id)
-
-    @Interface.private_api(allowed_methods=["get"])
-    def walker_queue_wait(self, task_id: str, timeout: int = 30):
-        """
-        Forcely wait the queues until executed.
-
-        :param task_id: the task need to wait for result
-        :param timeout: force timeout on your current request
-            to avoid hang up if there's too many task running currently
-        """
-        task = JsOrc.svc("task", TaskService)
-        if not task.is_running():
-            return "Task hook is not yet initialized!"
-
-        if not task_id:
-            return "Task id is required!"
-        else:
-            return task.get_by_task_id(task_id, True, timeout)
-
-    @Interface.private_api()
-    def add_scheduled_walker(self, name: str, schedule: dict, body: dict = {}):
-        """
-        Create a scheduled walker
-
-        :param name: name of the actual queue for reference.
-        :param schedule: can be interval or cron.
-            Format: {"type": {% interval or cron %}, "conf": {% conf %}, "one_off": {% true if one time only; default false %} }
-            Interval conf: {"every": {% integer %}, "period": {% days | hours | minutes | seconds | microseconds %}
-            cron conf: {"minute": "*", "hour": "*", "day_of_week": "*", "day_of_month": "*", "month_of_year": "*"}
-        :param body: your periodic_task kwargs (dict)
-            mst: requestor's master or superadmin requested master - defaults to requestor
-            wlk: target walker - defaults to init
-            ctx: context to be used upon call - defaults to {}
-            nd: target node - defaults to root
-            snt: preferred sentinel - defaults to master's active sentinel
-        """
-        task = JsOrc.svc("task", TaskService)
-        if not task.is_running():
-            return "Task hook is not yet initialized!"
-
-        from jaseci.prim.super_master import SuperMaster
-
-        if not isinstance(self, SuperMaster) or not body.get("mst"):
-            body["mst"] = self.jid
-
-        return (
-            "Scheduled Walker created successfully!"
-            if task.add_scheduled_queue(task.scheduled_walker, name, schedule, body)
-            else "Django is required to support scheduled walker!"
-        )
-
-    @Interface.admin_api()
-    def add_scheduled_sequence(self, name: str, schedule: dict, body: dict):
-        """
-        Create a scheduled sequence. More like call multiple api in order.
-
-        :param name: name of the actual queue for reference.
-        :param schedule: can be interval or cron.
-            Format: {"type": {% interval or cron %}, "conf": {% conf %}, "one_off": {% true if one time only; default false %} }
-            Interval conf: {"every": {% integer %}, "period": {% days | hours | minutes | seconds | microseconds %}
-            cron conf: {"minute": "*", "hour": "*", "day_of_week": "*", "day_of_month": "*", "month_of_year": "*"}
-        :param body: refer to jaseci/docs/docs/deployment/extension_services/task.md
-            under schedule sequence argument structure
-        """
-        task = JsOrc.svc("task", TaskService)
-        if not task.is_running():
-            return "Task hook is not yet initialized!"
-
-        return (
-            "Scheduled Sequence created successfully!"
-            if task.add_scheduled_queue(task.scheduled_sequence, name, schedule, body)
-            else "Django is required to support scheduled walker!"
-        )
-
-    @Interface.private_api()
-    def get_scheduled_queues(
-        self, limit: int = 10, offset: int = 0, asc: bool = False, search: str = None
-    ):
-        """
-        Get all periodic_task
-
-        :param limit: result limit
-        :param offset: query offset
-        :param asc: sorting
-        :param search: search by name
-        """
-        task = JsOrc.svc("task", TaskService)
-        if not task.is_running():
-            return "Task hook is not yet initialized!"
-
-        return task.get_scheduled_queues(limit, offset, asc, search, self)
-
-    @Interface.private_api()
-    def delete_scheduled_queue(self, scheduled_queue_id: int):
-        """
-        Delete specific periodic_task
-
-        :param scheduled_queue_id: the id of periodic task to delete
-        """
-        task = JsOrc.svc("task", TaskService)
-        if not task.is_running():
-            return "Task hook is not yet initialized!"
-
-        result = task.delete_scheduled_queue(scheduled_queue_id, self)
-        if result == None:
-            return "Django is required to support scheduled walker!"
-        return (
-            "Successfully deleted!"
-            if result
-            else f"Scheduled Queue with id({scheduled_queue_id}) is not existing!"
-        )

jaseci/extens/api/sentinel_api.py

@@ -1,271 +0,0 @@
-"""
-Sentinel api functions as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.utils.id_list import IdList
-from jaseci.prim.sentinel import Sentinel
-from jaseci.utils.utils import b64decode_str
-import uuid
-
-
-class SentinelApi:
-    """
-    Sentinel APIs
-
-    A sentinel is a unit in Jaseci that represents the organization and management of
-    a collection of architypes and walkers. In a sense, you can think of a sentinel
-    as a complete Jac implementation of a program or API application. Though its the
-    case that many sentinels can be interchangeably across any set of graphs, most
-    use cases will typically be a single sentinel shared by all users and managed by an
-    admin(s), or each users maintaining a single sentinel customized for their
-    individual needs. Many novel usage models are possible, but I'd point the beginner
-    to the model most analogous to typical server side software development to start
-    with. This model would be to have a single admin account responsible for updating
-    a single sentinel that all users would share for their individual graphs. This
-    model is achieved through using \\texttt{sentinel_register},
-    \\texttt{sentinel_active_global}, and \\texttt{global_sentinel_set}.
-    """
-
-    def __init__(self):
-        self.active_snt_id = None
-        self.sentinel_ids = IdList(self)
-
-    @Interface.private_api(cli_args=["code"])
-    def sentinel_register(
-        self,
-        name: str = "default",
-        code: str = "",
-        code_dir: str = "./",
-        opt_level: int = 4,
-        mode: str = "default",
-        encoded: bool = False,
-        auto_run: str = "init",
-        auto_run_ctx: dict = {},
-        auto_create_graph: bool = True,
-        set_active: bool = True,
-    ):
-        """
-        Create blank or code loaded sentinel and return object
-        Auto_run is the walker to execute on register (assumes active graph
-        is selected)
-        """
-        snt = self.sentinel_ids.get_obj_by_name(name, silent=True)
-        new_gph = None
-
-        if not snt:
-            snt = Sentinel(m_id=self._m_id, h=self._h, name=name)
-            self.sentinel_ids.add_obj(snt)
-            if auto_create_graph:
-                new_gph = self.graph_create(set_active=set_active)
-        if code:
-            self.sentinel_set(
-                code=code,
-                code_dir=code_dir,
-                encoded=encoded,
-                snt=snt,
-                mode=mode,
-                opt_level=opt_level,
-            )
-            if not snt.is_active:
-                return {
-                    "response": "Error in jac code",
-                    "errors": snt.errors + snt.runtime_errors,
-                    "success": False,
-                }
-        self.attempt_auto_run(sent=snt, walk_name=auto_run, ctx=auto_run_ctx)
-        if set_active:
-            self.sentinel_active_set(snt)
-        self.extract_snt_aliases(snt)
-        if new_gph:
-            return [snt.serialize(), new_gph]
-        return [snt.serialize()]
-
-    @Interface.private_api()
-    def sentinel_pull(self, set_active: bool = True, on_demand: bool = True):
-        """
-        Copies global sentinel to local master
-        """
-        glob_id = self._h.get_glob("GLOB_SENTINEL")
-        if not glob_id:
-            return {"response": "No global sentinel is available!", "success": False}
-        g_snt = self._h.get_obj(self._m_id, glob_id).duplicate()
-
-        snt = self.sentinel_ids.get_obj_by_name(g_snt.name, silent=True)
-        if not snt:
-            snt = Sentinel(m_id=self._m_id, h=self._h, name=g_snt.name)
-            self.sentinel_ids.add_obj(snt)
-        elif on_demand and snt.is_active:
-            return {"response": f"{snt} already active!", "success": True}
-        if set_active:
-            self.sentinel_active_set(snt)
-        return self.sentinel_set(code=g_snt.code_ir, snt=snt, mode="ir")
-
-    @Interface.private_api()
-    def sentinel_get(
-        self, snt: Sentinel = None, mode: str = "default", detailed: bool = False
-    ):
-        """
-        Get a sentinel rendered with specific mode
-        Valid modes: {default, code, ir, }
-        """
-        if mode == "code":
-            return snt._jac_ast.get_text()
-        elif mode == "ir":
-            return snt.ir_dict()
-        else:
-            return snt.serialize(detailed=detailed)
-
-    @Interface.private_api(cli_args=["code"])
-    def sentinel_set(
-        self,
-        code: str,
-        code_dir: str = "./",
-        opt_level: int = 4,
-        encoded: bool = False,
-        snt: Sentinel = None,
-        mode: str = "default",
-    ):
-        """
-        Set code/ir for a sentinel, only replaces walkers/archs in sentinel
-        Valid modes: {code, ir, }
-        """
-        if encoded:
-            code = b64decode_str(code)
-        if mode not in ["code", "default", "ir"]:
-            return {"response": f"Invalid mode to set {snt}", "success": False}
-        snt.register_code(code, dir=code_dir, mode=mode, opt_level=opt_level)
-        snt.propagate_access()
-
-        if snt.is_active:
-            self.extract_snt_aliases(snt)
-            return {"response": f"{snt} registered and active!", "success": True}
-        else:
-            return {
-                "response": f"{snt} code issues encountered!",
-                "success": False,
-                "errors": snt.errors + snt.runtime_errors,
-            }
-
-    @Interface.private_api()
-    def sentinel_list(self, detailed: bool = False):
-        """
-        Provide complete list of all sentinel objects
-        """
-        snts = []
-        for i in self.sentinel_ids.obj_list():
-            snts.append(i.serialize(detailed=detailed))
-        return snts
-
-    @Interface.private_api()
-    def sentinel_test(
-        self,
-        snt: Sentinel = None,
-        single: str = "",
-        detailed: bool = False,
-        profiling: bool = False,
-    ):
-        """
-        Run battery of test cases within sentinel and provide result
-        """
-        if not len(single):
-            single = None
-        return snt.run_tests(specific=single, profiling=profiling, detailed=detailed)
-
-    @Interface.private_api(cli_args=["snt"])
-    def sentinel_active_set(self, snt: Sentinel):
-        """
-        Sets the default sentinel master should use
-        """
-        self.active_snt_id = snt.jid
-        self.alias_register("active:sentinel", snt.jid)
-        return [f"Sentinel {snt.id} set as default"]
-
-    @Interface.private_api()
-    def sentinel_active_unset(self):
-        """
-        Unsets the default sentinel master should use
-        """
-        self.active_snt_id = None
-        self.alias_delete("active:sentinel")
-        return ["Default sentinel unset"]
-
-    @Interface.private_api()
-    def sentinel_active_global(
-        self,
-        auto_run: str = "",
-        auto_run_ctx: dict = {},
-        auto_create_graph: bool = False,
-        detailed: bool = False,
-    ):
-        """
-        Sets the default master sentinel to the global sentinel
-        Exclusive OR with pull strategy
-        """
-        ret = {"success": False, "sentinel": None}
-        glob_id = self._h.get_glob("GLOB_SENTINEL")
-        if not glob_id:
-            ret["response"] = "No global sentinel is available!"
-        else:
-            self.active_snt_id = "global"  # Resolved in interface
-            self.alias_register("active:sentinel", glob_id)
-            sent = self._h.get_obj(self._m_id, glob_id)
-            if auto_create_graph:
-                ret["graph_created"] = self.graph_create(set_active=True)
-            auto_run_ret = self.attempt_auto_run(
-                sent=sent, walk_name=auto_run, ctx=auto_run_ctx
-            )
-            if auto_run_ret:
-                ret["auto_run_result"] = auto_run_ret
-            ret["sentinel"] = sent.serialize(detailed=detailed)
-            ret["success"] = True
-            ret["response"] = f"Global sentinel {glob_id} set as default"
-        return ret
-
-    @Interface.private_api()
-    def sentinel_active_get(self, detailed: bool = False):
-        """
-        Returns the default sentinel master is using
-        """
-        id = self.active_snt_id
-        if id == "global":
-            id = self._h.get_glob("GLOB_SENTINEL")
-        if not id:
-            return {"response": "No default sentinel is selected!", "success": False}
-        else:
-            default = self._h.get_obj(self._m_id, id)
-            return default.serialize(detailed=detailed)
-
-    @Interface.private_api(cli_args=["snt"])
-    def sentinel_delete(self, snt: Sentinel):
-        """
-        Permanently delete sentinel with given id
-        """
-        self.remove_snt_aliases(snt)
-        if self.active_snt_id == snt.jid:
-            self.sentinel_active_unset()
-        self.sentinel_ids.destroy_obj(snt)
-        return [f"Sentinel {snt.id} successfully deleted"]
-
-    def active_snt(self):
-        sid = (
-            self._h.get_glob("GLOB_SENTINEL")
-            if self.active_snt_id == "global"
-            else self.active_snt_id
-        )
-        return self._h.get_obj(self._m_id, sid) if sid is not None else None
-
-    def attempt_auto_run(self, sent: Sentinel, walk_name, ctx):
-        if (
-            sent.arch_ids.has_obj_by_name(walk_name, kind="walker")
-            and self.active_gph_id
-        ):
-            nd = self._h.get_obj(self._m_id, self.active_gph_id)
-            return self.walker_run(name=walk_name, nd=nd, ctx=ctx, snt=sent)
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        for i in self.sentinel_ids.obj_list():
-            i.destroy()

jaseci/extens/api/share_api.py

@@ -1,64 +0,0 @@
-"""
-Object sharing APIs
-"""
-from jaseci.extens.api.interface import Interface
-from jaseci.prim.element import Element
-
-
-class ShareApi:
-    """
-    Sharing APIs.
-    """
-
-    def __init__(self):
-        self.incoming = {}
-
-    @Interface.private_api()
-    def share_object(
-        self, receiver: str, objs: list[Element] = [], read_only: bool = True
-    ):
-        """
-        Sharing an object with a user
-        obj: The list of elements to share
-        receiver: master of the receiving user
-        read_only: if set true, the object shared will be shared as read-only
-        """
-        # Get the master object by id
-        receiver_mast = self._h.get_obj(
-            caller_id=self.jid, item_id=receiver, override=True
-        )
-
-        for obj in objs:
-            # Grant read-only permission to the new user
-            self.object_perms_grant(obj, receiver_mast, read_only=read_only)
-            obj.save()
-
-            # Add the objet id to the receiver's incoming list
-            receiver_mast.incoming[str(obj.id)] = {"jid": self.jid, "name": self.name}
-
-        receiver_mast.save()
-        self.save()
-
-        return {
-            "objects": [str(obj) for obj in objs],
-            "sharer": str(self),
-            "receiver": str(receiver_mast),
-        }
-
-    @Interface.private_api()
-    def share_incoming_pop(self, obj_id: str):
-        """
-        Remove an item from the incoming list
-        """
-        try:
-            self.incoming.pop(obj_id)
-            return True
-        except Exception:
-            return None
-
-    @Interface.private_api()
-    def share_incoming_list(self):
-        """
-        Get the incoming objects
-        """
-        return self.incoming

jaseci/extens/api/super_api.py

@@ -1,65 +0,0 @@
-"""
-Super (master) api as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.prim.master import Master
-
-
-class SuperApi:
-    """Super APIs for creating nicknames for UUIDs and other long strings"""
-
-    @Interface.admin_api(cli_args=["name"])
-    def master_createsuper(
-        self,
-        name: str,
-        password: str = "",
-        global_init: str = "",
-        global_init_ctx: dict = {},
-        other_fields: dict = {},
-    ):
-        """
-        Create a super instance and return root node super 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.superuser_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.admin_api()
-    def master_allusers(
-        self, limit: int = 0, offset: int = 0, asc: bool = False, search: str = None
-    ):
-        """
-        Returns info on a set of users, limit specifies the number of users to
-        return and offset specfies where to start
-        NOTE: Abstract interface to be overridden
-        """
-
-    @Interface.admin_api(cli_args=["mast"])
-    def master_become(self, mast: Master):
-        """
-        Sets the default master master should use
-        """
-        self.caller = mast.jid
-        self.save()
-        return {"response": f"You are now {mast.name}"}
-
-    @Interface.admin_api(cli_args=["mast"])
-    def master_unbecome(self):
-        """
-        Unsets the default master master should use
-        """
-        self.caller = None
-        return {"response": f"You are now {self.name}"}

jaseci/extens/api/tests/test_architype_api.py

@@ -1,66 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class ArchitypeApiTest(CoreTest):
-    """Unit tests for Jac Architype APIs"""
-
-    fixture_src = __file__
-
-    def test_architype_register(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("hello_world.jac")}],
-        )
-
-        ret = self.call(
-            self.smast,
-            [
-                "architype_register",
-                {
-                    "code": self.load_jac("test_architype.jac"),
-                    "encoded": False,
-                },
-            ],
-        )
-
-        self.assertEqual(ret["success"], True)
-        self.assertEqual(ret["architype"]["name"], "test_architype")
-
-        architype_list_ret = self.call(
-            self.smast,
-            ["architype_list", {"detailed": True}],
-        )
-
-        self.assertEqual(len(architype_list_ret), 7)
-
-    def test_architype_get(self):
-        self.call(
-            self.smast,
-            ["sentinel_register", {"code": self.load_jac("hello_world.jac")}],
-        )
-
-        ret = self.call(
-            self.smast,
-            [
-                "architype_register",
-                {
-                    "code": self.load_jac("test_architype.jac"),
-                    "encoded": False,
-                },
-            ],
-        )
-
-        architype_get_ret = self.call(
-            self.smast,
-            ["architype_get", {"arch": ret["architype"]["jid"]}],
-        )
-
-        architype_get_ret_code = self.call(
-            self.smast,
-            ["architype_get", {"arch": ret["architype"]["jid"], "mode": "code"}],
-        )
-
-        self.assertEqual(architype_get_ret["architype"]["name"], "test_architype")
-        self.assertEqual(
-            "walker test_architype" in architype_get_ret_code["code"], True
-        )