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

jaseci/prim/ability.py

@@ -1,93 +0,0 @@
-"""
-Action class for Jaseci
-
-Each action has an id, name, timestamp and it's set of edges.
-"""
-from jaseci.prim.element import Element
-from jaseci.jsorc.live_actions import live_actions
-from jaseci.jac.jac_set import JacSet
-import inspect
-import time
-
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.utils.actions.actions_manager import ActionManager
-from jaseci.jac.ir.jac_code import JacCode
-from jaseci.jac.interpreter.interp import Interp
-from jaseci.jac.machine.jac_scope import JacScope
-
-
-class Ability(Element, JacCode, Interp):
-    """
-    Abilities class for Jaseci
-    """
-
-    def __init__(
-        self, code_ir=None, preset_in_out=None, access_list=None, *args, **kwargs
-    ):
-        self.preset_in_out = preset_in_out  # Not using _ids convention
-        self.access_list = access_list
-        Element.__init__(self, *args, **kwargs)
-        JacCode.__init__(self, code_ir=code_ir)
-        Interp.__init__(self)
-
-    def run_ability(self, here, visitor):
-        """
-        Run ability
-        """
-        self.push_scope(
-            JacScope(
-                parent=self,
-                name=f"a_run:{self.get_jac_ast().loc_str()}",
-                has_obj=here,
-                here=here,
-                visitor=visitor,
-            )
-        )
-        self.run_code_block(self.get_jac_ast())
-        self.pop_scope()
-
-    def run_action(self, param_list, scope, interp, jac_ast):
-        """
-        param_list should be passed as list of values to lib functions
-        Also note that Jac stores preset_in_out as input/output list of hex
-        ids since preset_in_out doesn't use _ids convention
-        """
-        action_name = self.name
-        if not interp.check_builtin_action(action_name):
-            interp.rt_error(f"Cannot execute {action_name} - Not Found", jac_ast)
-            return None
-        func = live_actions[action_name]
-        args = inspect.getfullargspec(func)
-        self.do_auto_conversions(args, param_list)
-        args = args[0] + args[4]
-
-        action_manager = JsOrc.get("action_manager", ActionManager)
-        action_manager.pre_action_call_hook()
-
-        ts = time.time()
-        try:
-            if "meta" in args:
-                param_list["kwargs"]["meta"] = {
-                    "m_id": scope.parent._m_id,
-                    "h": scope.parent._h,
-                    "scope": scope,
-                    "interp": interp,
-                }
-            result = func(*param_list["args"], **param_list["kwargs"])
-        except Exception as e:
-            interp.rt_error(e, jac_ast, True)
-        t = time.time() - ts
-        action_manager.post_action_call_hook(action_name, t)
-        return result
-
-    def do_auto_conversions(self, args, params):
-        """
-        Automatically make conversions for jac to internal, e.g., list to jac_set
-        """
-        for i in args.annotations.keys():
-            if args.annotations[i] == JacSet:
-                idx = args.args.index(i)
-                if idx < len(params["args"]):
-                    params["args"][idx] = JacSet(in_list=params["args"][idx])
-                if i in params["kwargs"]:
-                    params["kwargs"][i] = JacSet(in_list=params["kwargs"][i])

jaseci/prim/architype.py

@@ -1,89 +0,0 @@
-"""
-Architype class for Jaseci
-
-Each architype is a registered templatized version of instances of any Jaseci
-abstractions or collections of instances (e.g., subgraphs, etc)
-"""
-from jaseci.prim.element import Element
-from jaseci.jac.interpreter.architype_interp import ArchitypeInterp
-from jaseci.jac.ir.jac_code import JacCode
-from jaseci.utils.id_list import IdList
-
-
-class Architype(Element, JacCode, ArchitypeInterp):
-    """Architype class for Jaseci"""
-
-    def __init__(self, code_ir=None, is_async=False, *args, **kwargs):
-        self.super_archs = list()
-        self.anchor_var = None
-        self.private_vars = []
-        self.has_vars = []
-        self.entry_ability_ids = IdList(self)
-        self.activity_ability_ids = IdList(self)
-        self.exit_ability_ids = IdList(self)
-
-        # async handling for walker
-        self.is_async = is_async
-
-        Element.__init__(self, *args, **kwargs)
-        JacCode.__init__(self, code_ir)
-        ArchitypeInterp.__init__(self)
-
-    def run(self):
-        """
-        Create set of new object instances from architype if needed
-        """
-        return self.run_architype(jac_ast=self.get_jac_ast())
-
-    def get_actions(self, action_types: list):
-        actions = IdList(self, auto_save=False)
-        for i in self.arch_with_supers():
-            for j in action_types:
-                actions += getattr(i, j)
-        return actions
-
-    def get_entry_abilities(self):
-        return self.get_actions(["entry_ability_ids"])
-
-    def get_activity_abilities(self):
-        return self.get_actions(["activity_ability_ids"])
-
-    def get_exit_abilities(self):
-        return self.get_actions(["exit_ability_ids"])
-
-    def get_all_abilities(self):
-        return self.get_actions(
-            ["entry_ability_ids", "activity_ability_ids", "exit_ability_ids"]
-        )
-
-    def arch_with_supers(self):
-        archs = [self]
-        for i in self.super_archs:
-            obj = self.parent().arch_ids.get_obj_by_name(name=i, kind=self.kind)
-            archs += obj.arch_with_supers()
-        return archs
-
-    def derived_types(self):
-        names = []
-        for i in self.arch_with_supers():
-            names += i.super_archs + [i.name]
-        return names
-
-    def get_architype(self):
-        return self
-
-    def is_instance(self, name):
-        return name in self.derived_types()
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        des = (
-            self.activity_ability_ids.obj_list()
-            + self.entry_ability_ids.obj_list()
-            + self.exit_ability_ids.obj_list()
-        )
-        for i in des:
-            i.destroy()
-        super().destroy()

jaseci/prim/edge.py

@@ -1,172 +0,0 @@
-"""
-Edge class for Jaseci
-
-Each edge has an id, name, timestamp, the from node at the element of the edge
-and the to node it is pointing to.
-"""
-from jaseci.prim.element import Element
-from jaseci.prim.obj_mixins import Anchored
-from jaseci.utils.utils import logger
-import uuid
-import sys
-
-
-class Edge(Element, Anchored):
-    """Edge class for Jaseci"""
-
-    def __init__(self, **kwargs):
-        self.from_node_id = None
-        self.to_node_id = None
-        self.bidirected: bool = False
-        Anchored.__init__(self)
-        Element.__init__(self, **kwargs)
-
-    def from_node(self):
-        """Returns node edge is pointing from"""
-        ret = (
-            self._h.get_obj(self._m_id, self.from_node_id)
-            if self.from_node_id
-            else None
-        )
-        if not ret:
-            logger.critical(str(f"{self} disconnected from source node"))
-            return None
-        else:
-            return ret
-
-    def to_node(self):
-        """Returns node edge is pointing to"""
-        if not self.to_node_id:
-            return None
-        ret = self._h.get_obj(self._m_id, self.to_node_id) if self.to_node_id else None
-        if not ret:
-            logger.critical(str(f"{self} disconnected to target node"))
-            return None
-        else:
-            return ret
-
-    def nodes(self):
-        """Returns both nodes connected to edge in a list"""
-        return [self.to_node(), self.from_node()]
-
-    def opposing_node(self, node_obj):
-        """Returns opposite node edge is pointing from node_obj"""
-        node_set = [self.to_node_id, self.from_node_id]
-        try:
-            node_set.remove(node_obj.jid)
-            return self._h.get_obj(self._m_id, node_set[0])
-        except ValueError:
-            logger.critical(str(f"{self} disconnected to node {node_obj}"))
-            return None
-
-    def connect(self, source, target, bi_dir=False):
-        """
-        Connects both ends of the edge
-        """
-        self.from_node_id = source.jid
-        self.to_node_id = target.jid
-        source.smart_add_edge(self)
-        target.smart_add_edge(self)
-        self.set_bidirected(bi_dir)
-        self.save()
-        return True
-
-    def set_bidirected(self, bidirected: bool):
-        """Sets/unsets edge to be bidirected"""
-        self.bidirected = bidirected
-        self.save()
-
-    def is_bidirected(self):
-        """Check if edge is bidirected"""
-        return self.bidirected
-
-    def connects(self, source=None, target=None, ignore_direction=False):
-        """Test if a node or nodes are connected by edge"""
-        if not source and not target:
-            return False
-        if self.bidirected or ignore_direction:
-            if source and source.jid not in [self.from_node_id, self.to_node_id]:
-                return False
-            if target and target.jid not in [self.from_node_id, self.to_node_id]:
-                return False
-        else:
-            if source and source.jid != self.from_node_id:
-                return False
-            if target and target.jid != self.to_node_id:
-                return False
-        return True
-
-    def is_fast(self):
-        return sys.getsizeof(self.context) < 2000
-
-    def save(self):
-        """
-        Write self through hook to persistent storage
-        """
-
-        if self.is_fast():
-            self._persist = False
-            if self.from_node_id:
-                self.from_node().save()
-            if self.to_node_id:
-                self.to_node().save()
-        super().save()
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        base = self.from_node()
-        target = self.to_node()
-        base.smart_remove_edge(self) if base else None
-        target.smart_remove_edge(self) if target else None
-        super().destroy()
-
-    def dot_str(self, node_map=None, edge_map=None, detailed=False):
-        """
-        DOT representation
-        from_node -> to_node [context_key=contect_value]
-        """
-
-        def handle_str(str):
-            return str[:32].replace('"', '\\"')
-
-        from_name = (
-            uuid.UUID(self.from_node().jid).hex
-            if node_map is None
-            else node_map.index(self.from_node().jid)
-        )
-        to_name = (
-            uuid.UUID(self.to_node().jid).hex
-            if node_map is None
-            else node_map.index(self.to_node().jid)
-        )
-        dstr = f'"n{from_name}" -> "n{to_name}" [ '
-
-        if detailed:
-            dstr += f'id="{uuid.UUID(self.jid).hex}", '
-
-        label = ""
-        if edge_map:
-            label = f"e{edge_map.index(self.jid)}"
-        if self.name != "generic":
-            label += f":{self.name}"
-
-        dstr += f'label="{label}"'
-
-        if self.bidirected:
-            dstr += ', dir="both"'
-
-        edge_dict = self.context
-        for i in self.private_values():
-            edge_dict.pop(i)
-
-        if edge_dict and detailed:
-            for k, v in edge_dict.items():
-                if not isinstance(v, str) or v == "":
-                    continue
-                dstr += f', {k}="{handle_str(v)}"'
-
-        dstr += " ]"
-
-        return dstr + "\n"

jaseci/prim/element.py

@@ -1,233 +0,0 @@
-"""
-Base Jaseci object class
-
-Naming conventions
-* '_ids', '_id' - appended to lists of ids as feilds of jaseci objects
-* 'obj' - used to represent a jaseci object
-* 'item' - Items are kv pairs derived from item class, dont use elsewhere
-* 'store' - refers to persistent store for hooks from engine, (dont use db)
-"""
-
-import copy
-import json
-import uuid
-from datetime import datetime
-
-from jaseci.prim.obj_mixins import Hookable
-from jaseci.jsorc.memory import MemoryHook
-from jaseci.utils.id_list import IdList
-from jaseci.utils.json_handler import JaseciJsonEncoder, json_str_to_jsci_dict
-from jaseci.utils.utils import log_var_out, logger, camel_to_snake
-
-__version__ = "1.0.0"
-element_fields = None
-
-
-class Element(Hookable):
-    """
-    Base class for Jaseci for standard info shared across all objects types in
-    Jaseci. This class also includes a method for dumping the non-general items
-    as a single dictionary. The :meth:`jsci_payload` function automatically
-    finds relevant non general fields and returns a dictionary of them.
-
-    Keep in mind that when a valid hook is passed, the item writes itself on
-    creation.
-
-    Auto save should be faulse when loading from database so a new UUID is
-    not randomly created and saved back to db on load
-
-    TODO: Make below content a documentation variable and link in a few places
-    Keep in mind the postfix of '_ids' on feilds of derived classes of element
-    is a Jaseci convention for lists of uuids that are stored as hex and loaded
-    as type UUID.
-
-    NOTE: All fields of elements and it's derived classes are assumed to be
-    json serializable types
-    """
-
-    def __init__(
-        self,
-        name="basic",
-        kind="generic",
-        auto_save=True,
-        **kwargs,
-    ):
-        self.name = name
-        self.kind = kind
-        self.jid = uuid.uuid4().urn
-        self.j_timestamp = datetime.utcnow().isoformat()
-        self.j_type = camel_to_snake(type(self).__name__)
-        Hookable.__init__(self, **kwargs)
-        if self.is_master():
-            self.set_master(self.jid)
-        if auto_save:
-            self.save()
-
-    @property
-    def id(self):
-        return uuid.UUID(self.jid)
-
-    @id.setter
-    def id(self, obj):
-        self.jid = obj.urn
-
-    @property
-    def timestamp(self):
-        return datetime.fromisoformat(self.j_timestamp)
-
-    @timestamp.setter
-    def timestamp(self, obj):
-        self.j_timestamp = obj.isoformat()
-
-    def is_master(self, super_check=False, silent=True):
-        """Check if self is a master"""
-        ret = True
-        if "master" not in self.j_type:
-            ret = False
-            if not silent:
-                logger.error(f"{self} is not master")
-        if super_check and "super" not in self.j_type:
-            ret = False
-            if not silent:
-                logger.error(f"{self} does not have super master status")
-        return ret
-
-    def get_master(self):
-        """Get the master of an element"""
-        return self._h.get_obj(self._m_id, self.j_master)
-
-    def duplicate(self, persist_dup: bool = False):
-        """
-        Duplicates elements by creating copy with new id
-        Hook override to duplicate into mem / another store
-        """
-        kwargs = {"m_id": self._m_id, "h": self._h, "persist": persist_dup}
-        dup = type(self)(**kwargs)
-        id_save = dup.id
-        for i in dup.__dict__.keys():
-            if type(dup.__dict__[i]) == IdList:
-                setattr(dup, i, IdList(parent_obj=dup, in_list=self.__dict__[i]))
-            else:
-                setattr(dup, i, self.__dict__[i])
-        dup.id = id_save
-        dup.timestamp = datetime.utcnow()
-        dup.save()
-        return dup
-
-    def is_equivalent(self, obj):
-        """
-        Duplicates elements by creating copy with new id
-        """
-        if self.j_type != obj.j_type:
-            return False
-        for i in vars(self).keys():
-            if not i.startswith("_") and not callable(getattr(self, i)):
-                if i != "jid" and i != "j_timestamp":
-                    if getattr(self, i) != getattr(obj, i):
-                        return False
-        return True
-
-    def jsci_payload(self):
-        """
-        Returns all data fields and values of jaseci object as json string.
-        This grabs any fields that are added into inherited objects. Useful for
-        saving and loading item.
-        """
-        global element_fields
-        if element_fields is None:
-            element_fields = dir(Element(m_id=0, h=MemoryHook()))
-        obj_fields = []
-        for i in vars(self).keys():
-            if not i.startswith("_") and i not in element_fields:
-                obj_fields.append(i)
-        obj_dict = {}
-        for i in obj_fields:
-            obj_dict[i] = getattr(self, i)
-        return json.dumps(obj_dict, cls=JaseciJsonEncoder)
-
-    def serialize(self, deep=0, detailed=False):
-        """
-        Serialize Jaseci object
-        """
-        jdict = {}
-        key_fields = [
-            "name",
-            "kind",
-            "jid",
-            "j_type",
-            "context",
-            "code_sig",
-            "j_timestamp",
-            "version",
-            "to_node_id",
-            "from_node_id",
-        ]
-        for i in vars(self).keys():
-            if not i.startswith("_"):
-                if not detailed and i not in key_fields:
-                    continue
-                jdict[i] = copy.copy(vars(self)[i])
-                if not detailed and i == "context":
-                    for j in self.private_values():
-                        del jdict[i][j]
-                if deep > 0 and isinstance(jdict[i], IdList):
-                    for j in range(len(jdict[i])):
-                        jdict[i][j] = copy.copy(
-                            self._h.get_obj(self._m_id, jdict[i][j]).serialize(deep - 1)
-                        )
-        return jdict
-
-    def json(self, deep=0, detailed=False):
-        """
-        Returns entire self object as Json string
-
-        deep indicates number of levels to unwind uuids
-        """
-        return json.dumps(
-            self.serialize(deep, detailed=detailed), indent=4, cls=JaseciJsonEncoder
-        )
-
-    def json_load(self, blob):
-        """Loads self from json blob"""
-        jdict = json_str_to_jsci_dict(blob, parent_obj=self)
-        self.dict_load(jdict=jdict)
-
-    def dict_load(self, jdict):
-        """Loads self from dict"""
-        for i in jdict.keys():
-            if i in vars(self).keys():
-                setattr(self, i, jdict[i])
-
-    def get_deep_obj_list(self, objs=None):
-        """Recursively get all contained Jaseci objects and return id_list"""
-        if objs is None:
-            objs = []
-        objs.append(self)
-        for i in self.__dict__.keys():
-            if str(i).endswith("_ids") and isinstance(self.__dict__[i], IdList):
-                for j in self.__dict__[i].obj_list():
-                    if j not in objs:
-                        j.get_deep_obj_list(objs=objs)
-        return objs
-
-    def propagate_access(self, set_access=None):
-        """Propagate permission through id_lists hierarchy"""
-        if set_access is None:
-            set_access = self.j_access
-        for i in self.get_deep_obj_list():
-            i.j_access = set_access
-
-    def log_output(self, val):
-        """
-        Utility to log out variable in pretty format
-        """
-        log_var_out(val)
-
-    def __str__(self):
-        """
-        String representation is of the form type:name:kind
-        """
-        return self.j_type + ":" + self.kind + ":" + self.name + ":" + self.jid
-
-    def __repr__(self):
-        return self.__str__()

jaseci/prim/graph.py

@@ -1,26 +0,0 @@
-"""
-Graph  class for Jaseci
-
-"""
-from jaseci.prim.node import Node
-from jaseci.utils.id_list import IdList
-
-
-class Graph(Node):
-    """Graph class for Jaseci"""
-
-    def __init__(self, **kwargs):
-        self.hd_node_ids = IdList(self)
-        Node.__init__(self, **kwargs)
-        self.name = "root"
-        self.kind = "node"
-
-        # Node.__init__(self, name="root", kind="node", **kwargs)
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        for i in self.hd_node_ids.obj_list():
-            i.destroy()
-        super().destroy()

jaseci/prim/master.py

@@ -1,64 +0,0 @@
-"""
-Main master handler for each user of Jaseci, serves as main interface between
-between user and Jaseci
-"""
-
-from jaseci.prim.element import Element
-from jaseci.extens.api.alias_api import AliasAPI
-from jaseci.extens.api.object_api import ObjectApi
-from jaseci.extens.api.graph_api import GraphApi
-from jaseci.extens.api.sentinel_api import SentinelApi
-from jaseci.extens.api.walker_api import WalkerApi
-from jaseci.extens.api.architype_api import ArchitypeApi
-from jaseci.extens.api.config_api import ConfigApi
-from jaseci.extens.api.interface import Interface
-from jaseci.extens.api.master_api import MasterApi
-from jaseci.extens.api.jac_api import JacApi
-from jaseci.extens.api.user_api import UserApi
-from jaseci.extens.api.queue_api import QueueApi
-from jaseci.extens.api.webhook_api import WebhookApi
-from jaseci.extens.api.health_api import HealthApi
-from jaseci.jsorc.jsorc import JsOrc
-
-
-@JsOrc.context(name="master")
-class Master(
-    Element,
-    Interface,
-    MasterApi,
-    AliasAPI,
-    GraphApi,
-    ObjectApi,
-    SentinelApi,
-    WalkerApi,
-    ArchitypeApi,
-    JacApi,
-    UserApi,
-    QueueApi,
-    WebhookApi,
-    HealthApi,
-):
-    """Main class for master functions for user"""
-
-    def __init__(self, head_master=None, *args, **kwargs):
-        kwargs["m_id"] = None
-
-        Element.__init__(self, kind="Jaseci Master", *args, **kwargs)
-        MasterApi.__init__(self, head_master)
-        AliasAPI.__init__(self)
-        ConfigApi.__init__(self)
-        ObjectApi.__init__(self)
-        GraphApi.__init__(self)
-        WalkerApi.__init__(self)
-        SentinelApi.__init__(self)
-        Interface.__init__(self)
-
-    def destroy(self):
-        """
-        Destroys self from memory and persistent storage
-        """
-        GraphApi.destroy(self)
-        SentinelApi.destroy(self)
-        MasterApi.destroy(self)
-        WalkerApi.destroy(self)
-        super().destroy()