jaclang 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

jaclang/__init__.py

@@ -4,17 +4,17 @@ import sys
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "vendor"))
 
-
 from jaclang.jac.importer import jac_import  # noqa: E402
-from jaclang.utils.helpers import handle_jac_error  # noqa: E402
+from jaclang.jac.plugin.feature import JacFeature  # noqa: E402
 from jaclang.vendor import lark  # noqa: E402
 from jaclang.vendor import mypy  # noqa: E402
 from jaclang.vendor import pluggy  # noqa: E402
 
 __all__ = [
     "jac_import",
-    "handle_jac_error",
     "lark",
     "mypy",
     "pluggy",
 ]
+
+JacFeature.pm.load_setuptools_entrypoints("jac")

jaclang/cli/__init__.py

@@ -1,7 +1,6 @@
 """CLI for jaclang."""
 from jaclang import jac_import as jac_import
 
-
 cli = jac_import("cli")
 cmds = jac_import("cmds")
 

jaclang/cli/__jac_gen__/cli.py

@@ -5,7 +5,7 @@ represents the first such complete Jac program.
 """
 from __future__ import annotations
 from jaclang import jac_import as __jac_import__
-from jaclang.jac.plugin.feature import JacFeature as __JacFeature
+from jaclang.jac.plugin.feature import JacFeature as _JacFeature
 import inspect
 import argparse
 import cmd
@@ -13,7 +13,7 @@ __jac_import__(target='cli_impl', base_path=__file__)
 from cli_impl import *
 import cli_impl
 
-@__JacFeature.make_architype('obj')
+@_JacFeature.make_architype('obj')
 class Command:
     func: callable
     sig: inspect.Signature
@@ -25,7 +25,7 @@ class Command:
     def call(self, *args: list, **kwargs: dict) -> None:
         return self.func(*args, **kwargs)
 
-@__JacFeature.make_architype('obj')
+@_JacFeature.make_architype('obj')
 class CommandRegistry:
     registry: dict[str, Command]
     sub_parsers: argparse._SubParsersActionp
@@ -65,7 +65,7 @@ class CommandRegistry:
     def items(self) -> dict[str, Command]:
         return self.registry.items()
 
-@__JacFeature.make_architype('obj')
+@_JacFeature.make_architype('obj')
 class CommandShell(cmd.Cmd):
     (intro): str = 'Welcome to the Jac CLI!'
     (prompt): str = 'jac> '

jaclang/cli/__jac_gen__/cmds.py

@@ -5,7 +5,7 @@ represents the first such production Jac program.
 """
 from __future__ import annotations
 from jaclang import jac_import as __jac_import__
-from jaclang.jac.plugin.feature import JacFeature as __JacFeature
+from jaclang.jac.plugin.feature import JacFeature as _JacFeature
 __jac_import__(target='cli', base_path=__file__)
 from cli import cmd_registry as cmd_reg
 __jac_import__(target='cmds_impl', base_path=__file__)

jaclang/cli/__jac_gen__/cmds_impl.py

@@ -1,7 +1,7 @@
 """Implementations for the jac command line interface."""
 from __future__ import annotations
 from jaclang import jac_import as __jac_import__
-from jaclang.jac.plugin.feature import JacFeature as __JacFeature
+from jaclang.jac.plugin.feature import JacFeature as _JacFeature
 import os
 import shutil
 import unittest

jaclang/core/__init__.py

@@ -1,14 +1,8 @@
 """Core primitives for Jaseci."""
-# from jaclang import jac_import
+from jaclang import jac_import
 
-# prim = jac_import("corelib")
-# if not prim:
-#     raise ImportError("Could not import primitives, internal compile error")
+prim = jac_import("corelib")
+if not prim:
+    raise ImportError("Could not import primitives, internal compile error")
 
-# Object = prim.Object
-# Node = prim.Node
-# Edge = prim.Edge
-# Walker = prim.Walker
-# make_architype = prim.make_architype
-
-# exec_ctx = prim.exec_ctx
+JacPlugin = prim.JacPlugin

jaclang/core/__jac_gen__/corelib.py

@@ -0,0 +1,289 @@
+"""Jac's Key Elemental Abstractions"""
+from __future__ import annotations
+from enum import Enum as __jac_Enum__, auto as __jac_auto__
+from jaclang import jac_import as __jac_import__
+from jaclang.jac.plugin.feature import JacFeature as _JacFeature
+from datetime import datetime
+from uuid import UUID, uuid4
+from jaclang.jac.constant import EdgeDir
+from jaclang.jac.plugin import Architype, AbsRootHook, hookimpl
+__jac_import__(target='corelib_impl', base_path=__file__)
+from corelib_impl import *
+import corelib_impl
+
+class AccessMode(__jac_Enum__):
+    READ_ONLY = __jac_auto__()
+    READ_WRITE = __jac_auto__()
+    PRIVATE = __jac_auto__()
+
+@_JacFeature.make_architype('obj')
+class Memory:
+    (index): dict[UUID, Element] = {}
+    (save_queue): list[Element] = []
+
+    def get_obj(self, caller_id: UUID, item_id: UUID, override: bool=False) -> Element:
+        ret = self.index.get(item_id)
+        if override or ret.__is_readable(ret is not None and caller_id):
+            return ret
+
+    def has_obj(self, item_id: UUID) -> bool:
+        return item_id in self.index
+
+    def save_obj(self, caller_id: UUID, item: Element) -> None:
+        if item.is_writable(caller_id):
+            self.index[item.id] = item
+            if item._persist:
+                self.save_obj_list.add(item)
+        self.mem[item.id] = item
+        if item._persist:
+            self.save_obj_list.add(item)
+
+    def del_obj(self, caller_id: UUID, item: Element) -> None:
+        if item.is_writable(caller_id):
+            self.index.pop(item.id)
+            if item._persist:
+                self.save_obj_list.remove(item)
+
+    def get_object_distribution(self) -> dict:
+        dist = {}
+        for i in self.index.keys():
+            t = type(self.index[i])
+            if t in dist:
+                dist[t] += 1
+            else:
+                dist[t] = 1
+        return dist
+
+    def get_mem_size(self) -> float:
+        return sys.getsizeof(self.index) / 1024.0
+
+@_JacFeature.make_architype('obj')
+class ExecutionContext:
+    (master): Master = uuid4()
+    (memory): Memory = Memory()
+
+    def reset(self) -> None:
+        self.__init__()
+
+    def get_root(self) -> Node:
+        if type(self.master) == UUID:
+            self.master = Master()
+        return self.master.root_node
+'Global Execution Context, should be monkey patched by the user.'
+exec_ctx = ExecutionContext()
+
+@_JacFeature.make_architype('obj')
+class ElementInterface:
+    (jid): UUID = uuid4()
+    (timestamp): datetime = datetime.now()
+    (persist): bool = False
+    (access_mode): AccessMode = AccessMode.PRIVATE
+    (rw_access): set = set()
+    (ro_access): set = set()
+    (owner_id): UUID = exec_ctx.master
+    (mem): Memory = exec_ctx.memory
+
+    def make_public_ro(self) -> None:
+        self.__jinfo.access_mode = AccessMode.READ_ONLY
+
+    def make_public_rw(self) -> None:
+        self.__jinfo.access_mode = AccessMode.READ_WRITE
+
+    def make_private(self) -> None:
+        self.__jinfo.access_mode = AccessMode.PRIVATE
+
+    def is_public_ro(self) -> bool:
+        return self.__jinfo.access_mode == AccessMode.READ_ONLY
+
+    def is_public_rw(self) -> bool:
+        return self.__jinfo.access_mode == AccessMode.READ_WRITE
+
+    def is_private(self) -> bool:
+        return self.__jinfo.access_mode == AccessMode.PRIVATE
+
+    def is_readable(self, caller_id: UUID) -> bool:
+        return caller_id == self.owner_id or (self.is_public_read() or (caller_id in self.ro_access or caller_id in self.rw_access))
+
+    def is_writable(self, caller_id: UUID) -> bool:
+        return caller_id == self.owner_id or (self.is_public_write() or caller_id in self.rw_access)
+
+    def give_access(self, caller_id: UUID, read_write: bool=False) -> None:
+        if read_write:
+            self.rw_access.add(caller_id)
+        else:
+            add.ro_access.self(caller_id)
+
+    def revoke_access(self, caller_id: UUID) -> None:
+        self.ro_access.discard(caller_id)
+        self.rw_access.discard(caller_id)
+
+@_JacFeature.make_architype('obj')
+class ObjectInterface(ElementInterface):
+    pass
+
+@_JacFeature.make_architype('obj')
+class DataSpatialInterface(ObjectInterface):
+    (ds_entry_funcs): list[dict] = []
+    (ds_exit_funcs): list[dict] = []
+
+    @staticmethod
+    def on_entry(cls: type, triggers: list[type]) -> None:
+
+        def decorator(func: callable) -> callable:
+            cls.ds_entry_funcs.append({'types': triggers, 'func': func})
+
+            def wrapper(*args: list, **kwargs: dict) -> callable:
+                return func(*args, **kwargs)
+            return wrapper
+        return decorator
+
+    @staticmethod
+    def on_exit(cls: type, triggers: list[type]) -> None:
+
+        def decorator(func: callable) -> callable:
+            cls.ds_exit_funcs.append({'types': triggers, 'func': func})
+
+            def wrapper(*args: list, **kwargs: dict) -> callable:
+                return func(*args, **kwargs)
+            return wrapper
+        return decorator
+
+@_JacFeature.make_architype('obj')
+class NodeInterface(DataSpatialInterface):
+    (edges): dict[EdgeDir, list[Edge]] = {EdgeDir.IN: [], EdgeDir.OUT: []}
+
+    def connect_node(self, nd: Node, edg: Edge) -> Node:
+        edg.attach(self.py_obj, nd)
+        return self
+
+    def edges_to_nodes(self, dir: EdgeDir) -> list[Node]:
+        ret_nodes = []
+        if dir in [EdgeDir.OUT, EdgeDir.ANY]:
+            for i in self.edges[EdgeDir.OUT]:
+                ret_nodes.append(i.target)
+        elif dir in [EdgeDir.IN, EdgeDir.ANY]:
+            for i in self.edges[EdgeDir.IN]:
+                ret_nodes.append(i.source)
+        return ret_nodes
+
+    def __call__(self, walk: Walker) -> None:
+        if not isinstance(walk, Walker):
+            raise TypeError('Argument must be a Walker instance')
+        walk(self)
+
+@_JacFeature.make_architype('obj')
+class EdgeInterface(DataSpatialInterface):
+    (source): Node = None
+    (target): Node = None
+    (dir): EdgeDir = None
+
+    def apply_dir(self, dir: EdgeDir) -> Edge:
+        self.dir = dir
+        return self
+
+    def attach(self, src: Node, trg: Node) -> Edge:
+        if self.dir == EdgeDir.IN:
+            self.source = trg
+            self.target = src
+            src._jac_.edges[EdgeDir.IN].append(self)
+            trg._jac_.edges[EdgeDir.OUT].append(self)
+        else:
+            self.source = src
+            self.target = trg
+            src._jac_.edges[EdgeDir.OUT].append(self)
+            trg._jac_.edges[EdgeDir.IN].append(self)
+        return self
+
+    def __call__(self, walk: Walker) -> None:
+        if not isinstance(walk, Walker):
+            raise TypeError('Argument must be a Walker instance')
+        walk(self._jac_.target)
+
+@_JacFeature.make_architype('obj')
+class WalkerInterface(DataSpatialInterface):
+    (path): list[Node] = []
+    (next): list[Node] = []
+    (ignores): list[Node] = []
+    (disengaged): bool = False
+
+    def visit_node(self, nds: list[Node] | (list[Edge] | (Node | Edge))) -> None:
+        if isinstance(nds, list):
+            for i in nds:
+                if i not in self.ignores:
+                    self.next.append(i)
+        elif nds not in self.ignores:
+            self.next.append(nds)
+        return len(nds) if isinstance(nds, list) else 1
+
+    def ignore_node(self, nds: list[Node] | (list[Edge] | (Node | Edge))) -> None:
+        if isinstance(nds, list):
+            for i in nds:
+                self.ignores.append(i)
+        else:
+            self.ignores.append(nds)
+
+    def disengage_now(self) -> None:
+        self.next = []
+        self.disengaged = True
+
+    def __call__(self, nd: Node) -> None:
+        self._jac_.path = []
+        self._jac_.next = [nd]
+        walker_type = self.__class__.__name__
+        while len(self._jac_.next):
+            nd = self._jac_.next.pop(0)
+            node_type = nd.__class__.__name__
+            for i in nd._jac_ds_.ds_entry_funcs:
+                if i['func'].__qualname__.split('.')[0] == node_type and type(self) in i['types']:
+                    i['func'](nd, self)
+                if self._jac_.disengaged:
+                    return
+            for i in self._jac_ds_.ds_entry_funcs:
+                if i['func'].__qualname__.split('.')[0] == walker_type and (type(nd) in i['types'] or nd in i['types']):
+                    i['func'](self, nd)
+                if self._jac_.disengaged:
+                    return
+            for i in self._jac_ds_.ds_exit_funcs:
+                if i['func'].__qualname__.split('.')[0] == walker_type and (type(nd) in i['types'] or nd in i['types']):
+                    i['func'](self, nd)
+                if self._jac_.disengaged:
+                    return
+            for i in nd._jac_ds_.ds_exit_funcs:
+                if i['func'].__qualname__.split('.')[0] == node_type and type(self) in i['types']:
+                    i['func'](nd, self)
+                if self._jac_.disengaged:
+                    return
+            self._jac_.path.append(nd)
+        self._jac_.ignores = []
+
+@_JacFeature.make_architype('obj')
+class Root(AbsRootHook):
+    _jac_: NodeInterface
+    RootType: type
+
+@_JacFeature.make_architype('obj')
+class Master:
+    (_jac_): ElementInterface = ElementInterface()
+    (root_node): Root = Root(NodeInterface(), Root)
+
+@_JacFeature.make_architype('obj')
+class JacPlugin:
+
+    @staticmethod
+    def bind_architype(arch: AT, arch_type: str) -> bool:
+        match arch_type:
+            case 'obj':
+                arch._jac_ = ObjectInterface()
+            case 'node':
+                arch._jac_ = NodeInterface()
+            case 'edge':
+                arch._jac_ = EdgeInterface()
+            case 'walker':
+                arch._jac_ = WalkerInterface()
+            case _:
+                raise TypeError('Invalid archetype type')
+        return True
+
+    @staticmethod
+    def get_root() -> Architype:
+        return exec_ctx.get_root()

jaclang/core/__jac_gen__/corelib_impl.py

@@ -0,0 +1,220 @@
+"""Jac's Key Elemental Abstractions"""
+from __future__ import annotations
+from enum import Enum as __jac_Enum__, auto as __jac_auto__
+import sys
+from uuid import UUID, uuid4
+from jaclang.jac.constant import EdgeDir
+from jaclang.jac.plugin import hookimpl
+
+def o_Memory_c_get_obj(self, caller_id: UUID, item_id: UUID, override: bool=False) -> Element:
+    ret = self.index.get(item_id)
+    if override or ret.__is_readable(ret is not None and caller_id):
+        return ret
+
+def o_Memory_c_has_obj(self, item_id: UUID) -> bool:
+    return item_id in self.index
+
+def o_Memory_c_save_obj(self, caller_id: UUID, item: Element) -> None:
+    if item.is_writable(caller_id):
+        self.index[item.id] = item
+        if item._persist:
+            self.save_obj_list.add(item)
+    self.mem[item.id] = item
+    if item._persist:
+        self.save_obj_list.add(item)
+
+def o_Memory_c_del_obj(self, caller_id: UUID, item: Element) -> None:
+    if item.is_writable(caller_id):
+        self.index.pop(item.id)
+        if item._persist:
+            self.save_obj_list.remove(item)
+
+def o_Memory_c_get_object_distribution(self) -> dict:
+    dist = {}
+    for i in self.index.keys():
+        t = type(self.index[i])
+        if t in dist:
+            dist[t] += 1
+        else:
+            dist[t] = 1
+    return dist
+
+def o_Memory_c_get_mem_size(self) -> float:
+    return sys.getsizeof(self.index) / 1024.0
+
+def o_ExecutionContext_c_get_root(self) -> None:
+    if type(self.master) == UUID:
+        self.master = Master()
+    return self.master.root_node
+
+def o_ExecutionContext_c_reset(self) -> None:
+    self.__init__()
+
+class e_AccessMode(__jac_Enum__):
+    READ_ONLY = __jac_auto__()
+    READ_WRITE = __jac_auto__()
+    PRIVATE = __jac_auto__()
+
+def o_ElementInterface_c_make_public_ro(self) -> None:
+    self.__jinfo.access_mode = AccessMode.READ_ONLY
+
+def o_ElementInterface_c_make_public_rw(self) -> None:
+    self.__jinfo.access_mode = AccessMode.READ_WRITE
+
+def o_ElementInterface_c_make_private(self) -> None:
+    self.__jinfo.access_mode = AccessMode.PRIVATE
+
+def o_ElementInterface_c_is_public_ro(self) -> bool:
+    return self.__jinfo.access_mode == AccessMode.READ_ONLY
+
+def o_ElementInterface_c_is_public_rw(self) -> bool:
+    return self.__jinfo.access_mode == AccessMode.READ_WRITE
+
+def o_ElementInterface_c_is_private(self) -> bool:
+    return self.__jinfo.access_mode == AccessMode.PRIVATE
+
+def o_ElementInterface_c_is_readable(self, caller_id: UUID) -> bool:
+    return caller_id == self.owner_id or (self.is_public_read() or (caller_id in self.ro_access or caller_id in self.rw_access))
+
+def o_ElementInterface_c_is_writable(self, caller_id: UUID) -> bool:
+    return caller_id == self.owner_id or (self.is_public_write() or caller_id in self.rw_access)
+
+def o_ElementInterface_c_give_access(self, caller_id: UUID, read_write: bool=False) -> None:
+    if read_write:
+        self.rw_access.add(caller_id)
+    else:
+        add.ro_access.self(caller_id)
+
+def o_ElementInterface_c_revoke_access(self, caller_id: UUID) -> None:
+    self.ro_access.discard(caller_id)
+    self.rw_access.discard(caller_id)
+
+def o_DataSpatialInterface_c_on_entry(self, cls: type, triggers: list) -> None:
+
+    def decorator(func: callable) -> callable:
+        cls.ds_entry_funcs.append({'types': triggers, 'func': func})
+
+        def wrapper(*args: list, **kwargs: dict) -> callable:
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+def o_DataSpatialInterface_c_on_exit(self, cls: type, triggers: list) -> None:
+
+    def decorator(func: callable) -> callable:
+        cls.ds_exit_funcs.append({'types': triggers, 'func': func})
+
+        def wrapper(*args: list, **kwargs: dict) -> callable:
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+def o_NodeInterface_c_connect_node(self, nd: Node, edg: Edge) -> Node:
+    edg.attach(self.py_obj, nd)
+    return self
+
+def o_NodeInterface_c_edges_to_nodes(self, dir: EdgeDir) -> list[Node]:
+    ret_nodes = []
+    if dir in [EdgeDir.OUT, EdgeDir.ANY]:
+        for i in self.edges[EdgeDir.OUT]:
+            ret_nodes.append(i.target)
+    elif dir in [EdgeDir.IN, EdgeDir.ANY]:
+        for i in self.edges[EdgeDir.IN]:
+            ret_nodes.append(i.source)
+    return ret_nodes
+
+def o_EdgeInterface_c_apply_dir(self, dir: EdgeDir) -> Edge:
+    self.dir = dir
+    return self
+
+def o_EdgeInterface_c_attach(self, src: Node, trg: Node) -> Edge:
+    if self.dir == EdgeDir.IN:
+        self.source = trg
+        self.target = src
+        src._jac_.edges[EdgeDir.IN].append(self)
+        trg._jac_.edges[EdgeDir.OUT].append(self)
+    else:
+        self.source = src
+        self.target = trg
+        src._jac_.edges[EdgeDir.OUT].append(self)
+        trg._jac_.edges[EdgeDir.IN].append(self)
+    return self
+
+def o_WalkerInterface_c_visit_node(self, nds: list[Node] | (list[Edge] | (Node | Edge))) -> None:
+    if isinstance(nds, list):
+        for i in nds:
+            if i not in self.ignores:
+                self.next.append(i)
+    elif nds not in self.ignores:
+        self.next.append(nds)
+    return len(nds) if isinstance(nds, list) else 1
+
+def o_WalkerInterface_c_ignore_node(self, nds: list[Node] | (list[Edge] | (Node | Edge))) -> None:
+    if isinstance(nds, list):
+        for i in nds:
+            self.ignores.append(i)
+    else:
+        self.ignores.append(nds)
+
+def o_WalkerInterface_c_disengage_now(self) -> None:
+    self.next = []
+    self.disengaged = True
+
+def o_NodeInterface_c___call__(self, walk: Walker) -> None:
+    if not isinstance(walk, Walker):
+        raise TypeError('Argument must be a Walker instance')
+    walk(self)
+
+def o_EdgeInterface_c___call__(self, walk: Walker) -> None:
+    if not isinstance(walk, Walker):
+        raise TypeError('Argument must be a Walker instance')
+    walk(self._jac_.target)
+
+def o_WalkerInterface_c___call__(self, nd: Node) -> None:
+    self._jac_.path = []
+    self._jac_.next = [nd]
+    walker_type = self.__class__.__name__
+    while len(self._jac_.next):
+        nd = self._jac_.next.pop(0)
+        node_type = nd.__class__.__name__
+        for i in nd._jac_ds_.ds_entry_funcs:
+            if i['func'].__qualname__.split('.')[0] == node_type and type(self) in i['types']:
+                i['func'](nd, self)
+            if self._jac_.disengaged:
+                return
+        for i in self._jac_ds_.ds_entry_funcs:
+            if i['func'].__qualname__.split('.')[0] == walker_type and (type(nd) in i['types'] or nd in i['types']):
+                i['func'](self, nd)
+            if self._jac_.disengaged:
+                return
+        for i in self._jac_ds_.ds_exit_funcs:
+            if i['func'].__qualname__.split('.')[0] == walker_type and (type(nd) in i['types'] or nd in i['types']):
+                i['func'](self, nd)
+            if self._jac_.disengaged:
+                return
+        for i in nd._jac_ds_.ds_exit_funcs:
+            if i['func'].__qualname__.split('.')[0] == node_type and type(self) in i['types']:
+                i['func'](nd, self)
+            if self._jac_.disengaged:
+                return
+        self._jac_.path.append(nd)
+    self._jac_.ignores = []
+
+@hookimpl
+def o_JacPlugin_c_bind_architype(self, arch: AT, arch_type: str) -> bool:
+    match arch_type:
+        case 'obj':
+            arch._jac_ = ObjectInterface()
+        case 'node':
+            arch._jac_ = NodeInterface()
+        case 'edge':
+            arch._jac_ = EdgeInterface()
+        case 'walker':
+            arch._jac_ = WalkerInterface()
+        case _:
+            raise TypeError('Invalid archetype type')
+    return True
+
+@hookimpl
+def o_JacPlugin_c_get_root(self) -> None:
+    return exec_ctx.get_root()