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

jaseci/extens/api/alias_api.py

@@ -1,140 +0,0 @@
-"""
-Alias api as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-
-
-class AliasAPI:
-    """
-    Alias APIs for creating nicknames for UUIDs and other long strings
-
-    The alias set of APIs provide a set of `alias' management functions for
-    creating and managing aliases for long strings such as UUIDs. If an alias'
-    name is used as a parameter value in any API call, that parameter will see
-    the alias' value instead. Given that references to all sentinels, walkers,
-    nodes, etc. utilize UUIDs, it becomes quite useful to create pneumonic
-    names for them. Also, when registering   sentinels, walkers, architype
-    handy aliases are automatically generated. These generated aliases can
-    then be managed using the alias APIs. Keep in mind that whenever an alias
-    is created, all parameter values submitted to any API with the alias name
-    will be replaced internally by its value. If you get in a bind, simply use
-    the clear or delete alias APIs.
-    """
-
-    def __init__(self):
-        self.alias_map = {}
-
-    @Interface.private_api(cli_args=["name"])
-    def alias_register(self, name: str, value: str):
-        """Create string to string alias mapping that caller can use.
-
-        Either create new alias string to string mappings or replace
-        an existing mappings of a given alias name. Once registered the
-        alias mapping is instantly active.
-
-        Args:
-            name (str): The name for the alias created by caller.
-            value (str): The value for that name to map to (i.e., UUID)
-
-        Returns:
-            json: Fields include
-                'response': Message of mapping that was created
-        """
-        self.alias_map[name] = value
-        self.save()
-        return {"response": f"Alias from '{name}' to '{value}' set!"}
-
-    @Interface.private_api()
-    def alias_list(self):
-        """List all string to string alias that caller can use.
-
-        Returns dictionary object of name to value mappings currently active.
-        This API is quite useful to track not only the aliases the caller
-        creates, but also the aliases automatically created as various Jaseci
-        objects (walkers, architypes, sentinels, etc.) are created, changed,
-        or destroyed.
-
-        Returns:
-            dictionary: Dictionary of active mappings
-                'name': 'value'
-                ...
-        """
-        return self.alias_map
-
-    @Interface.private_api(cli_args=["name"])
-    def alias_delete(self, name: str):
-        """Delete an active string to string alias mapping.
-
-        Removes a specific alias by its name. Only the alias is removed no
-        actual objects are affected. Future uses of this name will not be
-        mapped.
-
-        Args:
-            name (str): The name for the alias to be removed from caller.
-
-        Returns:
-            dictionary: Fields include
-                'response': Message of success/failure to remove alias
-                'success': True/False based on delete actually happening
-        """
-        if name in self.alias_map.keys():
-            del self.alias_map[name]
-            self.save()
-            return {"response": f"Alias {name} successfully deleted", "success": True}
-        else:
-            return {"response": f"Alias {name} not present", "success": False}
-
-    @Interface.private_api()
-    def alias_clear(self):
-        """Remove all string to string alias that client can use.
-
-        Removes a all aliases. No actual objects are affected. Aliases will
-        continue to be automatically generated when creating other Jaseci
-        objects.
-
-        Returns:
-            dictionary: Fields include
-                'response': Message of number of alias removed
-                'removed': Number of aliases removed
-        """
-        n = len(self.alias_map.keys())
-        self.alias_map = {}
-        self.save()
-        return {"response": f"All {n} aliases deleted", "removed": n}
-
-    def extract_snt_aliases(self, snt):
-        """
-        Extract and register all aliases from sentinel
-        """
-        self.alias_register(f"sentinel:{snt.name}", snt.jid)
-        for i in snt.arch_ids.obj_list():
-            self.extract_arch_aliases(snt, i)
-        self.save()
-
-    def extract_arch_aliases(self, snt, arch):
-        """
-        Extract and register all aliases from architype
-        """
-        if arch.kind == "walker":
-            self.alias_register(f"{snt.name}:walker:{arch.name}", arch.jid)
-        else:
-            self.alias_register(f"{snt.name}:architype:{arch.name}", arch.jid)
-
-    def remove_snt_aliases(self, snt):
-        """
-        Extract and register all aliases from sentinel
-        """
-        self.alias_delete(f"sentinel:{snt.name}")
-        for i in snt.arch_ids.obj_list():
-            self.remove_arch_aliases(snt, i)
-        self.save()
-
-    def remove_arch_aliases(self, snt, arch):
-        """
-        Extract and register all aliases from architype
-        """
-        if arch.kind == "walker":
-            self.alias_delete(f"{snt.name}:walker:{arch.name}")
-        else:
-            self.alias_delete(f"{snt.name}:architype:{arch.name}")

jaseci/extens/api/architype_api.py

@@ -1,197 +0,0 @@
-"""
-Architype api functions as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.prim.architype import Architype
-from jaseci.prim.sentinel import Sentinel
-from jaseci.utils.utils import b64decode_str
-
-
-class ArchitypeApi:
-    """Architype APIs for creating and managing Jaseci architypes
-
-    The architype set of APIs allow for the addition and removing of
-    architypes. Given a Jac implementation of an architype these APIs are
-    designed for creating, compiling, and managing architypes that can be
-    used by Jaseci. There are two ways to add an architype to Jaseci, either
-    through the management of sentinels using the sentinel API, or by
-    registering independent architypes with these architype APIs. These
-    APIs are also used for inspecting and managing existing arichtypes that
-    a Jaseci instance is aware of.
-    """
-
-    @Interface.private_api(cli_args=["code"])
-    def architype_register(
-        self, code: str, encoded: bool = False, snt: Sentinel = None
-    ):
-        """Create an architype based on the code passed and return object.
-
-        This register API allows for the creation or replacement/update of
-        an architype that can then be used by walkers in their interactions
-        of graphs. The code argument takes Jac source code for the single
-        architype. To load multiple architypes and walkers at the same time,
-        use sentinel register API.
-
-        Args:
-            code (str): The text (or filename) for an architypes Jac code
-            encoded (bool): True/False flag as to whether code is encode
-                in base64
-            snt (uuid): The UUID of the sentinel to be the owner of this
-                architype
-
-        Returns:
-            json: Fields include
-                'architype': Architype object if created otherwise null
-                'success': True/False whether register was successful
-                'errors': List of errors if register failed
-                'response': Message on outcome of register call
-        """
-        ret = {"architype": None, "success": False, "errors": []}
-        if encoded:
-            code = b64decode_str(code)
-        arch = snt.register_architype(code)
-        if arch:
-            self.extract_arch_aliases(snt, arch)
-            ret["architype"] = arch.serialize()
-            ret["success"] = True
-            ret["response"] = f"Successfully created {arch.name} architype"
-        else:
-            ret["errors"] = snt.errors
-            ret["response"] = "Errors occured"
-        return ret
-
-    @Interface.private_api()
-    def architype_get(
-        self, arch: Architype, mode: str = "default", detailed: bool = False
-    ):
-        """Get an architype rendered with specific mode
-
-        Args:
-            arch (uuid): The architype being accessed
-            mode (str): Valid modes: {default, code, ir, }
-            detailed (bool): Flag to give summary or complete set of fields
-
-        Returns:
-            json: Fields include (depends on mode)
-                'code': Formal source code for architype
-                'ir': Intermediate representation of architype
-                'architype': Architype object print
-        """
-        # ternary python example
-        a = 1 if True else 2
-
-        if mode == "code":
-            try:
-                return {"code": arch.get_jac_ast().src}
-            except AttributeError:
-                return {"code": "No code available for architype"}
-        elif mode == "ir":
-            return {"ir": arch.ir_dict()}
-        else:
-            return {"architype": arch.serialize(detailed=detailed)}
-
-    @Interface.private_api(cli_args=["code"])
-    def architype_set(self, arch: Architype, code: str, mode: str = "default"):
-        """Set code/ir for a architype
-
-        Args:
-            arch (uuid): The architype being set
-            code (str): The text (or filename) for an architypes Jac code/ir
-            mode (str): Valid modes: {default, code, ir, }
-
-        Returns:
-            json: Fields include (depends on mode)
-                'success': True/False whether set was successful
-                'errors': List of errors if set failed
-                'response': Message on outcome of set call
-        """
-        if mode == "code" or mode == "default":
-            arch.register(code)
-        elif mode == "ir":
-            arch.apply_ir(code)
-        else:
-            return {
-                "response": f"Invalid mode to set {arch}",
-                "success": False,
-                "errors": [],
-            }
-        if arch.is_active:
-            return {
-                "response": f"{arch} registered and active!",
-                "success": True,
-                "errors": [],
-            }
-        else:
-            return {
-                "response": f"{arch} registered and active!",
-                "success": True,
-                "errors": arch.errors,
-            }
-
-    @Interface.private_api()
-    def architype_list(
-        self, snt: Sentinel = None, kind: str = None, detailed: bool = False
-    ):
-        """List architypes known to sentinel
-
-        Args:
-            snt (uuid): The sentinel for which to list its architypes
-            detailed (bool): Flag to give summary or complete set of fields
-            kind (str): Architype kind used to narrow the result set
-
-        Returns:
-            json: List of architype objects
-        """
-        archs = []
-
-        for i in snt.arch_ids.obj_list():
-            if not kind:
-                archs.append(i.serialize(detailed=detailed))
-            elif i.kind == kind:
-                archs.append(i.serialize(detailed=detailed))
-
-        return archs
-
-    @Interface.private_api()
-    def architype_count(self, snt: Sentinel = None, kind: str = None):
-        """Return count of architypes
-
-        Args:
-            snt (uuid): The sentinel for which to list its architypes
-            detailed (bool): Flag to give summary or complete set of fields
-            kind (str): Architype kind used to narrow the result set from which the count is evaluated
-
-        Returns:
-            int: Count of architype objects
-        """
-        arch_objects = snt.arch_ids.obj_list()
-
-        if kind:
-            arch_objects = list(filter(lambda obj: obj.kind == kind, arch_objects))
-
-        return len(arch_objects)
-
-    @Interface.private_api(cli_args=["arch"])
-    def architype_delete(self, arch: Architype, snt: Sentinel = None):
-        """Permanently delete sentinel with given id
-
-        Args:
-            arch (uuid): The architype being set
-            snt (uuid): The sentinel for which to list its architypes
-
-        Returns:
-            json: Fields include (depends on mode)
-                'success': True/False whether command was successful
-                'response': Message on outcome of command
-        """
-
-        if arch.jid not in snt.arch_ids:
-            return {
-                "response": f"Architype {arch} not in sentinel {snt}",
-                "success": False,
-            }
-        self.remove_arch_aliases(snt, arch)
-        archid = arch.jid
-        snt.arch_ids.destroy_obj(arch)
-        return {"response": f"Architype {archid} successfully deleted", "success": True}

jaseci/extens/api/config_api.py

@@ -1,129 +0,0 @@
-"""
-Admin config api functions as a mixin
-"""
-
-from typing import Optional
-from json import dumps, loads
-from jaseci.extens.api.interface import Interface
-
-
-class ConfigApi:
-    """
-    Admin config APIs
-    Abstracted since there are no valid configs in core atm, see jaseci_serv
-    to see how used.
-    """
-
-    def __init__(self, *args, **kwargs):
-        self._valid_configs = [
-            "CONFIG_EXAMPLE",
-            "ACTION_SETS",
-            "REDIS_CONFIG",
-            "TASK_CONFIG",
-            "MAIL_CONFIG",
-            "PROME_CONFIG",
-            "ELASTIC_CONFIG",
-            "STRIPE_CONFIG",
-            "KUBE_CONFIG",
-            "JSORC_CONFIG",
-        ]
-
-    @Interface.admin_api(cli_args=["name"])
-    def config_get(self, name: str, do_check: bool = True):
-        """
-        Get a config
-        """
-        if do_check and not self.name_check(name):
-            return self.name_error(name)
-        return self._h.get_glob(name)
-
-    @Interface.admin_api(cli_args=["name"])
-    def config_set(self, name: str, value: str or dict, do_check: bool = True):
-        """
-        Set a config
-        """
-        if do_check and not self.name_check(name):
-            return self.name_error(name)
-
-        if not (value is None) and type(value) is dict:
-            value = dumps(value)
-
-        self._h.save_glob(name, value)
-        return [f"Config of '{name}' to '{value}' set!"]
-
-    @Interface.admin_api(cli_args=["name"])
-    def config_update(
-        self,
-        name: str,
-        field_key: str,
-        field_value: str
-        or int
-        or float
-        or list
-        or dict
-        or bool
-        or tuple
-        or None,  # json serializable types
-        do_check: bool = True,
-    ):
-        """
-        Update a key-value of a config
-        """
-        if do_check and not self.name_check(name):
-            return self.name_error(name)
-
-        conf = self._h.get_glob(name)
-        try:
-            conf = loads(conf)
-        except Exception:
-            return [
-                f"Config {name} is not a dictionary. Uses config_set to set the value for this config."
-            ]
-        if field_key not in conf:
-            return [f"Field {field_key} does not exist in config {name}"]
-
-        conf[field_key] = field_value
-        conf = dumps(conf)
-        self._h.save_glob(name, conf)
-        return [
-            f"Config of '{name}' is updated with {field_key}:{field_value}. Current config value: {conf}"
-        ]
-
-    @Interface.admin_api()
-    def config_list(self):
-        """
-        Check a config is present
-        """
-        return [v for v in self._h.list_glob() if v in self._valid_configs]
-
-    @Interface.admin_api()
-    def config_index(self):
-        """
-        List all valid configs
-        """
-        return self._valid_configs
-
-    @Interface.admin_api(cli_args=["name"])
-    def config_exists(self, name: str):
-        """
-        Check a config is present
-        """
-        return self._h.has_glob(name)
-
-    @Interface.admin_api(cli_args=["name"])
-    def config_delete(self, name: str, do_check: bool = True):
-        """
-        Delete a config
-        """
-        if do_check and not self.name_check(name):
-            return self.name_error(name)
-        self._h.destroy_glob(name)
-        return [f"{name} Deleted."]
-
-    def name_error(self, name):
-        """Much used error output"""
-        return [f"Config {name} not recognized, must be in {self._valid_configs}!"]
-
-    def name_check(self, name):
-        """Much used name check"""
-        return name in self._valid_configs

jaseci/extens/api/global_api.py

@@ -1,85 +0,0 @@
-"""
-Admin Global api functions as a mixin
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.prim.sentinel import Sentinel
-import uuid
-
-
-class GlobalApi:
-    """
-    Admin global APIs
-    """
-
-    @Interface.admin_api(cli_args=["name"])
-    def global_set(self, name: str, value: str):
-        """
-        Set a global
-        """
-        ret = {"success": True}
-        if name == "GLOB_SENTINEL" or name in self._valid_configs:
-            ret["response"] = f"{name} is sacred!"
-            ret["success"] = False
-        else:
-            self._h.save_glob(name, value)
-            ret["response"] = f"Global variable '{name}' to '{value}' set!"
-        return ret
-
-    @Interface.admin_api(cli_args=["name"])
-    def global_delete(self, name: str):
-        """
-        Delete a global
-        """
-        ret = {"success": True}
-        if name == "GLOB_SENTINEL" or name in self._valid_configs:
-            ret["response"] = f"{name} is sacred!"
-            ret["success"] = False
-        else:
-            self._h.destroy_glob(name)
-            ret["response"] = f"Global {name} deleted."
-        return ret
-
-    @Interface.admin_api()
-    def global_sentinel_set(self, snt: Sentinel = None):
-        """
-        Make a sentinel globally accessible and set it as the global sentinel
-        """
-        snt.make_read_only()
-        snt.propagate_access()
-        self._h.save_glob("GLOB_SENTINEL", snt.jid)
-        return {"response": f"Global sentinel set to '{snt}'!"}
-
-    @Interface.admin_api()
-    def global_sentinel_setaccess(self, snt: Sentinel = None):
-        """
-        Make a sentinel globally accessible
-        """
-        snt.make_read_only()
-        snt.propagate_access()
-        return {"response": f"Sentinel '{snt}' is now globally accessible (read-only)."}
-
-    @Interface.admin_api()
-    def global_sentinel_revokeaccess(self, snt: Sentinel = None):
-        """
-        Revoke the global accessibility of a sentinel. Making it private.
-        """
-        if snt.check_write_access(self._m_id):
-            snt.make_private()
-            snt.propagate_access()
-            return {"response": f"Sentinel '{snt}' is now private."}
-        else:
-            return {"response:" "Insufficient permission."}
-
-    @Interface.admin_api()
-    def global_sentinel_unset(self):
-        """
-        Unset a global sentinel
-        """
-        current = self.global_get("GLOB_SENTINEL")["value"]
-        if current:
-            snt = self._h.get_obj(self._m_id, current)
-            for i in snt.get_deep_obj_list():
-                i.make_private()
-        self._h.destroy_glob("GLOB_SENTINEL")
-        return {"response": "Global sentinel cleared!"}