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

jaseci/jac/jac_set.py

@@ -1,119 +0,0 @@
-"""
-Jac's set class for Jaseci
-
-Adds relevant operators to id_list for operations on sets of nodes and edges
-"""
-# from jaseci.utils.id_list import id_list
-from jaseci.utils.utils import logger
-from jaseci.prim.element import Element
-
-
-class JacSet(list):
-    """
-    Jac set class for operations in Jac lang
-    (keeps append ordering and no dups)
-    """
-
-    def __init__(self, in_list=None):
-        if in_list:
-            for i in in_list:
-                if i not in self:
-                    self.append(i)
-
-    def append(self, item):
-        if not isinstance(item, Element) or not hasattr(item, "anchor_value"):
-            logger.error(f"Invalid {type(item)} object {item} to be added to jac_set!")
-        elif item not in self:
-            list.append(self, item)
-
-    def add_obj(self, item: Element):
-        if item not in self:
-            self.append(item)
-
-    def obj_list(self):
-        return self
-
-    def __lt__(self, other):
-        """Returns reduced set where anchor value evals to other"""
-        ret = JacSet()
-        for i in self:
-            if i.anchor_value() < other:
-                ret.add_obj(i)
-        return ret
-
-    def __gt__(self, other):
-        """Returns reduced set where anchor value evals to other"""
-        ret = JacSet()
-        for i in self:
-            if i.anchor_value() > other:
-                ret.add_obj(i)
-        return ret
-
-    def __le__(self, other):
-        """Returns reduced set where anchor value evals to other"""
-        ret = JacSet()
-        for i in self:
-            if i.anchor_value() <= other:
-                ret.add_obj(i)
-        return ret
-
-    def __ge__(self, other):
-        """Returns reduced set where anchor value evals to other"""
-        ret = JacSet()
-        for i in self:
-            if i.anchor_value() >= other:
-                ret.add_obj(i)
-        return ret
-
-    def __eq__(self, other):
-        """Returns reduced set where anchor value evals to other"""
-        ret = JacSet()
-        for i in self:
-            if i.anchor_value() == other:
-                ret.add_obj(i)
-        return ret
-
-    def __ne__(self, other):
-        """Returns reduced set where anchor value evals to other"""
-        ret = JacSet()
-        for i in self:
-            if i.anchor_value() != other:
-                ret.add_obj(i)
-        return ret
-
-    def __add__(self, other):
-        """Returns new set with operation applied"""
-        ret = JacSet()
-        for i in self:
-            ret.add_obj(i)
-        for i in other:
-            if i not in ret:
-                ret.add_obj(i)
-        return ret
-
-    def __sub__(self, other):
-        """Returns new set with operation applied"""
-        ret = JacSet()
-        for i in self:
-            if i not in other:
-                ret.add_obj(i)
-        return ret
-
-    def __mul__(self, other):
-        """Returns new set with operation applied, mul is intersection"""
-        ret = JacSet()
-        for i in self:
-            if i in other:
-                ret.add_obj(i)
-        return ret
-
-    def __truediv__(self, other):
-        """Returns new set with operation applied, div is 'outersection'"""
-        ret = JacSet()
-        for i in self:
-            if i not in other:
-                ret.add_obj(i)
-        for i in other:
-            if i not in self:
-                ret.add_obj(i)
-        return ret

jaseci/jac/jsci_vm/disasm.py

@@ -1,94 +0,0 @@
-from jaseci.jac.jsci_vm.op_codes import JsCmp, JsOp, JsType, type_map
-from jaseci.jac.jsci_vm.inst_ptr import InstPtr, from_bytes
-from jaseci.utils.utils import logger
-from base64 import b64decode
-
-
-class DisAsm(InstPtr):
-    def __init__(self):
-        InstPtr.__init__(self)
-        self._asm = []
-
-    def disassemble(self, bytecode, to_screen=True, log_out=False):
-        if type(bytecode) == str:
-            bytecode = b64decode(bytecode.encode())
-        self._bytecode = bytearray(bytecode)
-        try:
-            while self._ip < len(self._bytecode):
-                op = JsOp(self._bytecode[self._ip])
-                if hasattr(self, f"dis_{op.name}"):
-                    getattr(self, f"dis_{op.name}")()
-                else:
-                    self._asm.append([op.name])
-                self._ip += 1
-            self.print() if to_screen else None
-            self.log() if log_out else None
-            return self._asm
-        except Exception:
-            logger.error(f"Disassembly Failed on Following Bytecode: {self._bytecode}")
-            self.print() if to_screen else None
-            self.log() if log_out else None
-
-    def print(self):
-        for i in self._asm:
-            print(*i)
-
-    def log(self):
-        for i in self._asm:
-            logger.info(str(i))
-
-    def op_COMPARE(self):  # noqa
-        ctyp = JsCmp(self.offset(1))
-        self._asm.append([self.cur_op(), ctyp.name])
-        self._ip += 1
-
-    def op_INCREMENT(self):  # noqa
-        ityp = JsCmp(self.offset(1))
-        self._asm.append([self.cur_op(), ityp.name])
-        self._ip += 1
-
-    def dis_LOAD_CONST(self):  # noqa
-        typ = JsType(self.offset(1))
-        operand2 = self.offset(2)
-        val = None
-        if typ in [JsType.TYPE]:
-            self._asm.append([self.cur_op(), typ.name, JsType(operand2).name])
-            self._ip += 2
-        elif typ in [JsType.INT]:
-            val = from_bytes(type_map[typ], self.offset(3, operand2))
-            self._asm.append([self.cur_op(), typ.name, operand2, val])
-            self._ip += 2 + operand2
-        elif typ in [JsType.STRING]:
-            str_len = from_bytes(type_map[JsType.INT], self.offset(3, operand2))
-            val = from_bytes(type_map[typ], self.offset(3 + operand2, str_len))
-            self._asm.append([self.cur_op(), typ.name, operand2, str_len, val])
-            self._ip += 2 + operand2 + str_len
-        elif typ in [JsType.FLOAT]:
-            val = from_bytes(float, self.offset(2, 8))
-            self._asm.append([self.cur_op(), typ.name, val])
-            self._ip += 1 + 8
-        elif typ in [JsType.BOOL]:
-            val = bool(self.offset(2))
-            self._asm.append([self.cur_op(), typ.name, val])
-            self._ip += 1 + 1
-
-    def dis_LOAD_VAR(self):  # noqa
-        name = from_bytes(str, self.offset(2, self.offset(1)))
-        self._asm.append([self.cur_op(), self.offset(1), name])
-        self._ip += 1 + self.offset(1)
-
-    def dis_CREATE_VAR(self):  # noqa
-        name = from_bytes(str, self.offset(2, self.offset(1)))
-        self._asm.append([self.cur_op(), self.offset(1), name])
-        self._ip += 1 + self.offset(1)
-
-    def dis_DEBUG_INFO(self):  # noqa
-        byte_len_l = self.offset(1)
-        line = from_bytes(int, self.offset(2, byte_len_l))
-        f_offset = byte_len_l + 2
-        byte_len_f = self.offset(f_offset)
-        jacfile = (
-            from_bytes(str, self.offset(f_offset + 1, byte_len_f)) if byte_len_f else 0
-        )
-        self._asm.append([self.cur_op(), byte_len_l, line, byte_len_f, jacfile])
-        self._ip += 2 + byte_len_l + byte_len_f

jaseci/jac/jsci_vm/inst_ptr.py

@@ -1,31 +0,0 @@
-from jaseci.jac.jsci_vm.op_codes import JsOp
-from struct import unpack
-
-
-def from_bytes(typ, val):
-    if typ == str:
-        if val is None:
-            return ""
-        return val.decode("unicode_escape")
-    if typ == float:
-        return unpack("d", val)[0]
-    else:
-        if val is None:
-            return 0
-        return typ.from_bytes(val, "little")
-
-
-class InstPtr:
-    def __init__(self):
-        self._ip = 0
-        self._bytecode = None
-
-    def offset(self, delta, range=None):
-        if range == 0:
-            return None
-        elif range is not None:
-            return self._bytecode[self._ip + delta : self._ip + delta + range]
-        return self._bytecode[self._ip + delta]
-
-    def cur_op(self):
-        return JsOp(self.offset(0)).name

jaseci/jac/jsci_vm/machine.py

@@ -1,188 +0,0 @@
-from jaseci.jac.jsci_vm.op_codes import JsCmp, JsOp, JsType, type_map, cmp_op_map
-from jaseci.jac.machine.machine_state import MachineState
-from jaseci.jac.jsci_vm.inst_ptr import InstPtr, from_bytes
-from jaseci.jac.machine.jac_value import JacValue
-from jaseci.jac.jsci_vm.disasm import DisAsm
-
-
-class Stack(object):
-    def __init__(self):
-        self._stk = []
-
-    def stack_is_empty(self) -> bool:
-        return len(self._stk) == 0
-
-    def pop(self):
-        if self.stack_is_empty():
-            raise Exception("JaseciMachine stack is empty")
-        return self._stk.pop()
-
-    def push(self, value):
-        self._stk.append(value)
-
-    def peak_stack(self, count=0):
-        if not count:
-            print(list(reversed(self._stk)))
-        else:
-            print(list(reversed(self._stk))[0:count])
-
-
-class VirtualMachine(MachineState, Stack, InstPtr):
-    def __init__(self, **kwargs):
-        Stack.__init__(self)
-        InstPtr.__init__(self)
-        MachineState.__init__(self, **kwargs)
-        self._op = self.build_op_call()
-        self._op_id = id(self)
-
-    def reset_vm(self):
-        Stack.__init__(self)
-        InstPtr.__init__(self)
-        if id(self) != self._op_id:
-            self._op = self.build_op_call()
-
-    def build_op_call(self):
-        op_map = {}
-        for op in JsOp:
-            op_map[op] = getattr(self, f"op_{op.name}")
-        return op_map
-
-    def run_bytecode(self, bytecode):
-        self.reset_vm()
-        self._bytecode = bytearray(bytecode)
-        try:
-            while self._ip < len(self._bytecode):
-                self._op[self._bytecode[self._ip]]()
-                self._ip += 1
-        except Exception as e:
-            self.disassemble(print_out=False, log_out=True)
-            raise e
-
-    def disassemble(self, print_out=True, log_out=False):
-        return DisAsm().disassemble(self._bytecode, print_out, log_out)
-
-    def op_PUSH_SCOPE(self):  # noqa
-        pass
-
-    def op_POP_SCOPE(self):  # noqa
-        pass
-
-    def op_ADD(self):  # noqa
-        val = self.pop()
-        val.value = val.value + self.pop().value
-        self.push(val)
-
-    def op_SUBTRACT(self):  # noqa
-        val = self.pop()
-        val.value = val.value - self.pop().value
-        self.push(val)
-
-    def op_MULTIPLY(self):  # noqa
-        val = self.pop()
-        val.value = val.value * self.pop().value
-        self.push(val)
-
-    def op_DIVIDE(self):  # noqa
-        val = self.pop()
-        val.value = val.value / self.pop().value
-        self.push(val)
-
-    def op_MODULO(self):  # noqa
-        val = self.pop()
-        val.value = val.value % self.pop().value
-        self.push(val)
-
-    def op_POWER(self):  # noqa
-        val = self.pop()
-        val.value = val.value ** self.pop().value
-        self.push(val)
-
-    def op_NEGATE(self):  # noqa
-        val = self.pop()
-        val.value = -(val.value)
-        self.push(val)
-
-    def op_COMPARE(self):  # noqa
-        ctyp = JsCmp(self.offset(1))
-        val = self.pop()
-        val.value = (
-            cmp_op_map[ctyp](val.value, self.pop().value)
-            if ctyp != JsCmp.NOT
-            else cmp_op_map[ctyp](val.value)
-        )
-        self.push(val)
-        self._ip += 1
-
-    def op_AND(self):  # noqa
-        val = self.pop()
-        val.value = val.value and self.pop().value
-        self.push(val)
-
-    def op_OR(self):  # noqa
-        val = self.pop()
-        val.value = val.value or self.pop().value
-        self.push(val)
-
-    def op_ASSIGN(self):  # noqa
-        dest = self.pop()
-        self.perform_assignment(dest, self.pop())
-
-    def op_COPY_FIELDS(self):  # noqa
-        dest = self.pop()
-        self.perform_copy_fields(dest, self.pop())
-
-    def op_INCREMENT(self):  # noqa
-        ityp = JsCmp(self.offset(1))
-        dest = self.pop()
-        self.perform_increment(dest, self.pop(), ityp)
-        self._ip += 1
-
-    def op_LOAD_CONST(self):  # noqa
-        typ = JsType(self.offset(1))
-        operand2 = self.offset(2)
-        if typ in [JsType.TYPE]:
-            val = type_map[JsType(operand2)]
-            self._ip += 2
-        elif typ in [JsType.INT]:
-            val = from_bytes(type_map[typ], self.offset(3, operand2))
-            self._ip += 2 + operand2
-        elif typ in [JsType.STRING]:
-            str_len = from_bytes(type_map[JsType.INT], self.offset(3, operand2))
-            val = from_bytes(type_map[typ], self.offset(3 + operand2, str_len))
-            self._ip += 2 + operand2 + str_len
-        elif typ in [JsType.FLOAT]:
-            val = from_bytes(float, self.offset(2, 8))
-            self._ip += 1 + 8
-        elif typ in [JsType.BOOL]:
-            val = bool(self.offset(2))
-            self._ip += 1 + 1
-        self.push(JacValue(self, value=val))
-
-    def op_LOAD_VAR(self):  # noqa
-        name = from_bytes(str, self.offset(2, self.offset(1)))
-        self.load_variable(name)
-        self._ip += 1 + self.offset(1)
-
-    def op_CREATE_VAR(self):  # noqa
-        name = from_bytes(str, self.offset(2, self.offset(1)))
-        self.load_variable(name, assign_mode=True)
-        self._ip += 1 + self.offset(1)
-
-    def op_REPORT(self):  # noqa
-        self.report.append(self.pop())
-
-    def op_ACTION_CALL(self):  # noqa
-        pass
-
-    def op_DEBUG_INFO(self):  # noqa
-        byte_len_l = self.offset(1)
-        line = from_bytes(int, self.offset(2, byte_len_l))
-        f_offset = byte_len_l + 2
-        byte_len_f = self.offset(f_offset)
-        jacfile = (
-            from_bytes(str, self.offset(f_offset + 1, byte_len_f))
-            if byte_len_f
-            else self._cur_jac_ast.loc[2]
-        )
-        self._ip += 2 + byte_len_l + byte_len_f
-        self._cur_jac_ast.loc = [line, 0, jacfile, {}]

jaseci/jac/jsci_vm/op_codes.py

@@ -1,82 +0,0 @@
-from enum import IntEnum, auto
-from jaseci.prim.edge import Edge
-from jaseci.prim.node import Node
-
-
-class JsOp(IntEnum):
-    PUSH_SCOPE = auto()
-    POP_SCOPE = auto()
-    ADD = auto()
-    SUBTRACT = auto()
-    MULTIPLY = auto()
-    DIVIDE = auto()
-    MODULO = auto()
-    POWER = auto()
-    NEGATE = auto()
-    COMPARE = auto()
-    AND = auto()
-    OR = auto()
-    ASSIGN = auto()
-    COPY_FIELDS = auto()
-    REPORT = auto()
-    ACTION_CALL = auto()
-    INCREMENT = auto()  # [type]
-    LOAD_CONST = auto()  # [type, bytes, (val)] / [type, (val)] / [type=type, type]
-    LOAD_VAR = auto()  # [bytes, (name)]
-    CREATE_VAR = auto()  # [bytes, (name)]
-    DEBUG_INFO = auto()  # [bytes, line, bytes, (jacfile)]
-
-
-class JsType(IntEnum):
-    TYPE = auto()
-    INT = auto()
-    FLOAT = auto()
-    STRING = auto()
-    LIST = auto()
-    DICT = auto()
-    BOOL = auto()
-    NULL = auto()
-    NODE = auto()
-    EDGE = auto()
-
-
-class JsCmp(IntEnum):
-    EE = auto()
-    LT = auto()
-    GT = auto()
-    LTE = auto()
-    GTE = auto()
-    NE = auto()
-    IN = auto()
-    NIN = auto()
-    NOT = auto()
-    PEQ = auto()
-    MEQ = auto()
-    TEQ = auto()
-    DEQ = auto()
-
-
-type_map = {
-    JsType.TYPE: type,
-    JsType.INT: int,
-    JsType.FLOAT: float,
-    JsType.STRING: str,
-    JsType.LIST: list,
-    JsType.DICT: dict,
-    JsType.BOOL: bool,
-    JsType.NULL: None,
-    JsType.NODE: Node,
-    JsType.EDGE: Edge,
-}
-
-cmp_op_map = {
-    JsCmp.NOT: lambda val: not val,
-    JsCmp.EE: lambda v1, v2: v1 == v2,
-    JsCmp.LT: lambda v1, v2: v1 < v2,
-    JsCmp.GT: lambda v1, v2: v1 > v2,
-    JsCmp.LTE: lambda v1, v2: v1 <= v2,
-    JsCmp.GTE: lambda v1, v2: v1 >= v2,
-    JsCmp.NE: lambda v1, v2: v1 != v2,
-    JsCmp.IN: lambda v1, v2: v1 in v2,
-    JsCmp.NIN: lambda v1, v2: v1 not in v2,
-}

jaseci/jac/jsci_vm/tests/test_codegen.py

@@ -1,31 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class TestCodegen(CoreTest):
-    """Unit tests for Jac Walker APIs"""
-
-    fixture_src = __file__
-
-    def test_simple_codegen(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("simple.jac")}],
-        )
-        # self.log(ret)
-        ret = self.call(self.mast, ["walker_run", {"name": "most_basic"}])
-        # self.log(ret)
-        # from jaseci.jac.ir.passes import PrinterPass
-        # PrinterPass(self.mast.active_snt()._jac_ast).run()
-        self.assertEqual(ret["report"][0], 5004)
-        self.assertEqual(ret["report"][1], 1)
-        self.assertEqual(ret["report"][2], "ab")
-        self.assertEqual(ret["report"][3], {"base": 5, "test": 5})
-        self.assertEqual(ret["report"][4], {"a": 3, "b": 55, "c": 311})
-
-    def test_unicode(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("unicode.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "unicode"}])
-        self.assertEqual(len(ret["report"]), 1)

jaseci/jac/machine/jac_scope.py

@@ -1,85 +0,0 @@
-"""
-Variable scope manager for Jac
-
-Utility for all runtime interaction with variables in different scopes
-"""
-from jaseci.jac.machine.jac_value import JacValue
-from jaseci.jsorc.live_actions import get_global_actions
-
-
-class JacScope:
-    def __init__(self, parent, name, has_obj=None, here=None, visitor=None):
-        self.parent = parent
-        self.name = name
-        self.local_scope = {}
-        self.has_obj = has_obj if has_obj else self
-        self.context = {}
-        self.action_sets = []
-        self._start_time = 0  # For profiling
-        self._total_time = 0  # For profiling
-        self._cum_start_time = None
-        self.set_refs(here, visitor)
-        self.setup_actions()
-
-    def setup_actions(self):
-        allactions = []
-        for i in self.action_sets:
-            allactions += i.obj_list()
-        self.action_sets = get_global_actions()
-        for i in allactions:
-            self.add_action(i)
-
-    def add_action(self, act):
-        group = act.name.split(".")[0]
-        if "." in act.name:
-            if group not in self.action_sets.keys():
-                self.action_sets[group] = {}
-            action = act.name.split(".")[1]
-            self.action_sets[group][action] = act
-        else:
-            self.action_sets[group] = act
-
-    def set_refs(self, here, visitor):
-        self.local_scope["here"] = here
-        self.local_scope["visitor"] = visitor
-        self.action_sets = []
-        if here:
-            self.action_sets += [here.get_architype().get_all_abilities()]
-        if visitor:
-            self.action_sets += [visitor.get_architype().get_all_abilities()]
-
-    def get_refs(self):
-        return {
-            "here": self.local_scope["here"],
-            "visitor": self.local_scope["visitor"],
-        }
-
-    def here(self):
-        return self.local_scope["here"]
-
-    def visitor(self):
-        return self.local_scope["visitor"]
-
-    def find_live_attr(self, name, allow_read_only=True):
-        """Finds binding for variable if not in standard scope"""
-        # check if var is in walker's context
-        if "context" in self.has_obj.__dict__ and name in self.has_obj.context.keys():
-            return JacValue(self.parent, ctx=self.has_obj, name=name)
-        elif name in self.action_sets.keys():
-            return JacValue(self.parent, ctx=self.action_sets, name=name)
-        return None
-
-    def get_live_var(self, name, create_mode=False):
-        """Returns live variable"""
-        found = None
-        # Lock for variable in various locations
-        if name in self.local_scope.keys():
-            found = JacValue(self.parent, ctx=self.local_scope, name=name)
-        else:
-            found = self.find_live_attr(name)
-        if found is None and create_mode:
-            self.local_scope[name] = None
-            return JacValue(self.parent, ctx=self.local_scope, name=name)
-        if found:
-            return found
-        return None