jaclang 0.3.1__tar.gz → 0.3.3__tar.gz

{jaclang-0.3.1 → jaclang-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.3.1
+Version: 0.3.3
 Home-page: https://github.com/Jaseci-Labs/jaclang
 Author: Jason Mars
 Author-email: jason@jaseci.org

{jaclang-0.3.1 → jaclang-0.3.3}/jaclang/cli/__init__.py

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

jaclang-0.3.3/jaclang/core/__init__.py

@@ -0,0 +1,8 @@
+"""Core primitives for Jaseci."""
+from jaclang import jac_import
+
+corelib = jac_import("corelib")
+if not corelib:
+    raise ImportError("Could not import primitives, internal jaseci error")
+
+JacPlugin = corelib.JacPlugin

{jaclang-0.3.1 → jaclang-0.3.3}/jaclang/core/__jac_gen__/corelib.py

@@ -1,15 +1,11 @@
 """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__()
@@ -74,6 +70,7 @@ exec_ctx = ExecutionContext()
 
 @_JacFeature.make_architype('obj')
 class ElementInterface:
+    ob: object
     (jid): UUID = uuid4()
     (timestamp): datetime = datetime.now()
     (persist): bool = False
@@ -167,7 +164,7 @@ class NodeInterface(DataSpatialInterface):
         return ret_nodes
 
     def __call__(self, walk: Walker) -> None:
-        if not isinstance(walk, Walker):
+        if not isinstance(walk._jac_, WalkerInterface):
             raise TypeError('Argument must be a Walker instance')
         walk(self)
 
@@ -227,63 +224,282 @@ class WalkerInterface(DataSpatialInterface):
         self.disengaged = True
 
     def __call__(self, nd: Node) -> None:
-        self._jac_.path = []
-        self._jac_.next = [nd]
+        self.path = []
+        self.next = [nd]
         walker_type = self.__class__.__name__
-        while len(self._jac_.next):
-            nd = self._jac_.next.pop(0)
+        while len(self.next):
+            nd = self.next.pop(0)
             node_type = nd.__class__.__name__
-            for i in nd._jac_ds_.ds_entry_funcs:
+            for i in nd.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:
+                if self.disengaged:
                     return
-            for i in self._jac_ds_.ds_entry_funcs:
+            for i in self.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:
+                if self.disengaged:
                     return
-            for i in self._jac_ds_.ds_exit_funcs:
+            for i in self.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:
+                if self.disengaged:
                     return
-            for i in nd._jac_ds_.ds_exit_funcs:
+            for i in nd.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:
+                if self.disengaged:
                     return
-            self._jac_.path.append(nd)
-        self._jac_.ignores = []
+            self.path.append(nd)
+        self.ignores = []
 
 @_JacFeature.make_architype('obj')
 class Root(AbsRootHook):
-    _jac_: NodeInterface
     RootType: type
+    (_jac_): NodeInterface | None = None
+
+    def __post_init__(self) -> None:
+        self._jac_ = NodeInterface(self)
 
 @_JacFeature.make_architype('obj')
 class Master:
-    (_jac_): ElementInterface = ElementInterface()
-    (root_node): Root = Root(NodeInterface(), Root)
+    (_jac_): ElementInterface | None = None
+    (root_node): Root = Root(Root)
+
+    def __post_init__(self) -> None:
+        self._jac_ = ElementInterface(self)
 
 @_JacFeature.make_architype('obj')
 class JacPlugin:
 
     @staticmethod
+    @hookimpl
     def bind_architype(arch: AT, arch_type: str) -> bool:
         match arch_type:
             case 'obj':
-                arch._jac_ = ObjectInterface()
+                arch._jac_ = ObjectInterface(arch)
             case 'node':
-                arch._jac_ = NodeInterface()
+                arch._jac_ = NodeInterface(arch)
             case 'edge':
-                arch._jac_ = EdgeInterface()
+                arch._jac_ = EdgeInterface(arch)
             case 'walker':
-                arch._jac_ = WalkerInterface()
+                arch._jac_ = WalkerInterface(arch)
             case _:
                 raise TypeError('Invalid archetype type')
         return True
 
     @staticmethod
+    @hookimpl
     def get_root() -> Architype:
-        return exec_ctx.get_root()
+        return exec_ctx.get_root()
+
+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(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(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: object) -> None:
+    if not isinstance(walk._jac_, WalkerInterface):
+        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.path = []
+    self.next = [nd]
+    walker_type = self.__class__.__name__
+    while len(self.next):
+        nd = self.next.pop(0)
+        node_type = nd.__class__.__name__
+        for i in nd.ds_entry_funcs:
+            if i['func'].__qualname__.split('.')[0] == node_type and type(self) in i['types']:
+                i['func'](nd, self)
+            if self.disengaged:
+                return
+        for i in self.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.disengaged:
+                return
+        for i in self.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.disengaged:
+                return
+        for i in nd.ds_exit_funcs:
+            if i['func'].__qualname__.split('.')[0] == node_type and type(self) in i['types']:
+                i['func'](nd, self)
+            if self.disengaged:
+                return
+        self.path.append(nd)
+    self.ignores = []
+
+def o_JacPlugin_c_bind_architype(arch: AT, arch_type: str) -> bool:
+    match arch_type:
+        case 'obj':
+            arch._jac_ = ObjectInterface(arch)
+        case 'node':
+            arch._jac_ = NodeInterface(arch)
+        case 'edge':
+            arch._jac_ = EdgeInterface(arch)
+        case 'walker':
+            arch._jac_ = WalkerInterface(arch)
+        case _:
+            raise TypeError('Invalid archetype type')
+    return True
+
+def o_JacPlugin_c_get_root() -> None:
+    return exec_ctx.get_root()

jaclang-0.3.1/jaclang/core/corelib_impl.jac → jaclang-0.3.3/jaclang/core/corelib.jac

@@ -1,9 +1,124 @@
 """Jac's Key Elemental Abstractions"""
 
-import:py sys;
+import:py from datetime, datetime;
 import:py from uuid, UUID, uuid4;
 import:py from jaclang.jac.constant, EdgeDir;
-import:py from jaclang.jac.plugin, hookimpl;
+import:py from jaclang.jac.plugin, Architype, AbsRootHook, hookimpl;
+
+enum AccessMode;
+
+obj Memory {
+    has index: dict[UUID, Element] = {},
+        save_queue: list[Element] = [];
+
+    #* Main Accessors *#
+    can get_obj(caller_id: UUID, item_id: UUID,
+                override: bool = False) -> Element;
+    can has_obj(item_id: UUID) -> bool;
+    can save_obj(caller_id: UUID, item: Element);
+    can del_obj(caller_id: UUID, item: Element);
+
+    #* Utility Functions *#
+    can get_object_distribution -> dict;
+    can get_mem_size -> float;
+}
+
+obj ExecutionContext {
+    has master: Master = :>uuid4,
+        memory: Memory = Memory();
+
+    can reset;
+    can get_root() -> Node;
+}
+
+"Global Execution Context, should be monkey patched by the user."
+glob exec_ctx = ExecutionContext();
+
+obj ElementInterface {
+    has ob: object,
+        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;
+
+    can make_public_ro;
+    can make_public_rw;
+    can make_private;
+    can is_public_ro -> bool;
+    can is_public_rw -> bool;
+    can is_private -> bool;
+    can is_readable(caller_id: UUID) -> bool;
+    can is_writable(caller_id: UUID) -> bool;
+    can give_access(caller_id: UUID, read_write: bool = False);
+    can revoke_access(caller_id: UUID);
+}
+
+obj ObjectInterface:ElementInterface: {}
+
+obj DataSpatialInterface:ObjectInterface: {
+    static has ds_entry_funcs: list[dict]=[],
+               ds_exit_funcs: list[dict]=[];
+
+    static can on_entry(cls: type, triggers: list[type]);
+    static can on_exit(cls: type, triggers: list[type]);
+}
+
+obj NodeInterface:DataSpatialInterface: {
+    has edges: dict[EdgeDir, list[Edge]]
+        = {EdgeDir.IN: [], EdgeDir.OUT: []};
+
+    can connect_node(nd: Node, edg: Edge) -> Node;
+    can edges_to_nodes(dir: EdgeDir) -> list[Node];
+    can __call__(walk: Walker);
+}
+
+obj EdgeInterface:DataSpatialInterface: {
+    has source: Node = None,
+        target: Node = None,
+        dir: EdgeDir = None;
+
+    can apply_dir(dir: EdgeDir) -> Edge;
+    can attach(src: Node, trg: Node) -> Edge;
+    can __call__(walk: Walker);
+}
+
+obj WalkerInterface:DataSpatialInterface: {
+    has path: list[Node] = [],
+        next: list[Node] = [],
+        ignores: list[Node] = [],
+        disengaged: bool = False;
+
+    can visit_node(nds: list[Node]|list[Edge]|Node|Edge);
+    can ignore_node(nds: list[Node]|list[Edge]|Node|Edge);
+    can disengage_now;
+    can __call__(nd: Node);
+}
+obj Root:AbsRootHook: {
+    has RootType: type;
+    has _jac_: NodeInterface|None = None;
+    can <pi> {
+        <self>._jac_ = NodeInterface(<self>);
+    }
+}
+
+obj Master {
+    has _jac_: ElementInterface|None = None;
+    has root_node: Root = Root(Root);
+    can <pi> {
+            <self>._jac_ = ElementInterface(<self>);
+    }
+}
+
+obj JacPlugin {
+    @hookimpl
+    static can bind_architype(arch: AT, arch_type: str) -> bool;
+    @hookimpl
+    static can get_root() -> Architype;
+}
 
 :obj:Memory:can:get_obj
 (caller_id: UUID, item_id: UUID, override: bool = False) -> Element {
@@ -234,11 +349,11 @@ import:py from jaclang.jac.plugin, hookimpl;
 
 
 :obj:NodeInterface:can:__call__
-(walk: Walker) {
-    if not (walk, Walker) :> isinstance {
-        raise ("Argument must be a Walker instance") :> TypeError;
+(walk: object) {
+    if not isinstance(walk._jac_, WalkerInterface) {
+        raise TypeError("Argument must be a Walker instance");
     }
-    <self> :> walk;
+    walk(<self>);
 }
 
 
@@ -252,65 +367,64 @@ import:py from jaclang.jac.plugin, hookimpl;
 
 :obj:WalkerInterface:can:__call__
 (nd: Node) {
-    <self>._jac_.path = [];
-    <self>._jac_.next = [nd];
+    <self>.path = [];
+    <self>.next = [nd];
     walker_type = <self>.__class__.__name__;
-    while <self>._jac_.next :> len {
-        nd = 0 :> <self>._jac_.next.pop;
+    while <self>.next :> len {
+        nd = 0 :> <self>.next.pop;
         node_type = nd.__class__.__name__;
 
-        for i in nd._jac_ds_.ds_entry_funcs {
+        for i in nd.ds_entry_funcs {
             if i['func'].__qualname__.split(".")[0] == node_type and
                 <self>:>type in i['types'] {
                 (nd, <self>) :> i['func'];
             }
-            if <self>._jac_.disengaged {return;}
+            if <self>.disengaged {return;}
         }
-        for i in <self>._jac_ds_.ds_entry_funcs {
+        for i in <self>.ds_entry_funcs {
             if i['func'].__qualname__.split(".")[0] == walker_type and
                 (nd:>type in i['types'] or nd in i['types']) {  # if nd==root direct chec
-                (<self>, nd) :> i['func'];
+                i['func'](<self>, nd);
             }
-            if <self>._jac_.disengaged {return;}
+            if <self>.disengaged {return;}
         }
-        for i in <self>._jac_ds_.ds_exit_funcs {
+        for i in <self>.ds_exit_funcs {
             if i['func'].__qualname__.split(".")[0] == walker_type and
             (nd:>type in i['types'] or nd in i['types']) {
-                (<self>, nd) :> i['func'];
+                 i['func'](<self>, nd);
             }
-            if <self>._jac_.disengaged {return;}
+            if <self>.disengaged {return;}
         }
-        for i in nd._jac_ds_.ds_exit_funcs {
+        for i in nd.ds_exit_funcs {
             if i['func'].__qualname__.split(".")[0] == node_type and
                 <self>:>type in i['types'] {
                 (nd, <self>) :> i['func'];
             }
-            if <self>._jac_.disengaged {return;}
+            if <self>.disengaged {return;}
         }
-        nd :> <self>._jac_.path.append;
+        nd :> <self>.path.append;
     }
-    <self>._jac_.ignores=[];
+    <self>.ignores=[];
 }
 
-@hookimpl
+
 :obj:JacPlugin:can:bind_architype
 (arch: AT, arch_type: str) -> bool {
     match arch_type {
         case 'obj':
-            arch._jac_ = ObjectInterface();
+            arch._jac_ = ObjectInterface(arch);
         case 'node':
-            arch._jac_ = NodeInterface();
+            arch._jac_ = NodeInterface(arch);
         case 'edge':
-            arch._jac_ = EdgeInterface();
+            arch._jac_ = EdgeInterface(arch);
         case 'walker':
-            arch._jac_ = WalkerInterface();
+            arch._jac_ = WalkerInterface(arch);
         case _:
             raise ("Invalid archetype type") :> TypeError;
     }
     return True;
 }
 
-@hookimpl
 :obj:JacPlugin:can:get_root
 () -> None {
     return exec_ctx.get_root();