jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/runtimelib/memory.py

@@ -0,0 +1,158 @@
+"""Core constructs for Jac Language."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pickle import dumps
+from shelve import Shelf, open
+from typing import Callable, Generator, Generic, Iterable, TypeVar
+from uuid import UUID
+
+from .architype import Anchor, NodeAnchor, Root, TANCH
+
+ID = TypeVar("ID")
+
+
+@dataclass
+class Memory(Generic[ID, TANCH]):
+    """Generic Memory Handler."""
+
+    __mem__: dict[ID, TANCH] = field(default_factory=dict)
+    __gc__: set[ID] = field(default_factory=set)
+
+    def close(self) -> None:
+        """Close memory handler."""
+        self.__mem__.clear()
+        self.__gc__.clear()
+
+    def find(
+        self,
+        ids: ID | Iterable[ID],
+        filter: Callable[[TANCH], TANCH] | None = None,
+    ) -> Generator[TANCH, None, None]:
+        """Find anchors from memory by ids with filter."""
+        if not isinstance(ids, Iterable):
+            ids = [ids]
+
+        return (
+            anchor
+            for id in ids
+            if (anchor := self.__mem__.get(id)) and (not filter or filter(anchor))
+        )
+
+    def find_one(
+        self,
+        ids: ID | Iterable[ID],
+        filter: Callable[[TANCH], TANCH] | None = None,
+    ) -> TANCH | None:
+        """Find one anchor from memory by ids with filter."""
+        return next(self.find(ids, filter), None)
+
+    def find_by_id(self, id: ID) -> TANCH | None:
+        """Find one by id."""
+        return self.__mem__.get(id)
+
+    def set(self, id: ID, data: TANCH) -> None:
+        """Save anchor to memory."""
+        self.__mem__[id] = data
+
+    def remove(self, ids: ID | Iterable[ID]) -> None:
+        """Remove anchor/s from memory."""
+        if not isinstance(ids, Iterable):
+            ids = [ids]
+
+        for id in ids:
+            self.__mem__.pop(id, None)
+            self.__gc__.add(id)
+
+
+@dataclass
+class ShelfStorage(Memory[UUID, Anchor]):
+    """Shelf Handler."""
+
+    __shelf__: Shelf[Anchor] | None = None
+
+    def __init__(self, session: str | None = None) -> None:
+        """Initialize memory handler."""
+        super().__init__()
+        self.__shelf__ = open(session) if session else None  # noqa: SIM115
+
+    def close(self) -> None:
+        """Close memory handler."""
+        if isinstance(self.__shelf__, Shelf):
+            from jaclang.plugin.feature import JacFeature as Jac
+
+            root = Jac.get_root().__jac__
+
+            for id in self.__gc__:
+                self.__shelf__.pop(str(id), None)
+                self.__mem__.pop(id, None)
+
+            for d in self.__mem__.values():
+                if d.persistent and d.hash != hash(dumps(d)):
+                    _id = str(d.id)
+                    if p_d := self.__shelf__.get(_id):
+                        if (
+                            isinstance(p_d, NodeAnchor)
+                            and isinstance(d, NodeAnchor)
+                            and p_d.edges != d.edges
+                            and root.has_connect_access(d)
+                        ):
+                            if not d.edges:
+                                self.__shelf__.pop(_id, None)
+                                continue
+                            p_d.edges = d.edges
+
+                        if root.has_write_access(d):
+                            if hash(dumps(p_d.access)) != hash(dumps(d.access)):
+                                p_d.access = d.access
+                            if hash(dumps(d.architype)) != hash(dumps(d.architype)):
+                                p_d.architype = d.architype
+
+                        self.__shelf__[_id] = p_d
+                    elif not (
+                        isinstance(d, NodeAnchor)
+                        and not isinstance(d.architype, Root)
+                        and not d.edges
+                    ):
+                        self.__shelf__[_id] = d
+
+            self.__shelf__.close()
+        super().close()
+
+    def find(
+        self,
+        ids: UUID | Iterable[UUID],
+        filter: Callable[[Anchor], Anchor] | None = None,
+    ) -> Generator[Anchor, None, None]:
+        """Find anchors from datasource by ids with filter."""
+        if not isinstance(ids, Iterable):
+            ids = [ids]
+
+        if isinstance(self.__shelf__, Shelf):
+            for id in ids:
+                anchor = self.__mem__.get(id)
+
+                if (
+                    not anchor
+                    and id not in self.__gc__
+                    and (_anchor := self.__shelf__.get(str(id)))
+                ):
+                    self.__mem__[id] = anchor = _anchor
+                if anchor and (not filter or filter(anchor)):
+                    yield anchor
+        else:
+            yield from super().find(ids, filter)
+
+    def find_by_id(self, id: UUID) -> Anchor | None:
+        """Find one by id."""
+        data = super().find_by_id(id)
+
+        if (
+            not data
+            and isinstance(self.__shelf__, Shelf)
+            and (data := self.__shelf__.get(str(id)))
+        ):
+            self.__mem__[id] = data
+
+        return data

jaclang/{core → runtimelib}/utils.py

@@ -11,7 +11,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.semtable import SemScope
 
 if TYPE_CHECKING:
-    from jaclang.core.constructs import NodeAnchor, NodeArchitype
+    from jaclang.runtimelib.constructs import NodeAnchor, NodeArchitype
 
 
 @contextmanager
@@ -37,12 +37,16 @@ def collect_node_connections(
         visited_nodes.add(current_node)
         edges = current_node.edges
         for edge_ in edges:
-            target = edge_._jac_.target
+            target = edge_.target
             if target:
                 connections.add(
-                    (current_node.obj, target._jac_.obj, edge_.__class__.__name__)
+                    (
+                        current_node.architype,
+                        target.architype,
+                        edge_.__class__.__name__,
+                    )
                 )
-                collect_node_connections(target._jac_, visited_nodes, connections)
+                collect_node_connections(target, visited_nodes, connections)
 
 
 def traverse_graph(
@@ -61,17 +65,20 @@ def traverse_graph(
     edge_limit: int,
 ) -> None:
     """Traverse the graph using Breadth-First Search (BFS) or Depth-First Search (DFS)."""
-    for edge in node._jac_.edges:
-        is_self_loop = id(edge._jac_.source) == id(edge._jac_.target)
-        is_in_edge = edge._jac_.target == node
-        if (traverse and is_in_edge) or edge._jac_.obj.__class__.__name__ in edge_type:
+    for edge in node.__jac__.edges:
+        is_self_loop = id(edge.source) == id(edge.target)
+        is_in_edge = edge.target == node.__jac__
+        if (traverse and is_in_edge) or edge.architype.__class__.__name__ in edge_type:
             continue
         if is_self_loop:
             continue  # lets skip self loop for a while, need to handle it later
-        else:
-            other_nd = edge._jac_.target if not is_in_edge else edge._jac_.source
+        elif (other_nda := edge.target if not is_in_edge else edge.source) and (
+            other_nd := other_nda.architype
+        ):
             new_con = (
-                (node, other_nd, edge) if not is_in_edge else (other_nd, node, edge)
+                (node, other_nd, edge.architype)
+                if not is_in_edge
+                else (other_nd, node, edge.architype)
             )
             if node in node_depths and node_depths[node] is not None:
                 if other_nd in node_depths:
@@ -113,18 +120,26 @@ def get_sem_scope(node: ast.AstNode) -> SemScope:
     a = (
         node.name
         if isinstance(node, ast.Module)
-        else node.name.value if isinstance(node, (ast.Enum, ast.Architype)) else ""
+        else (
+            node.name.value
+            if isinstance(node, (ast.Enum, ast.Architype))
+            else node.name_ref.sym_name if isinstance(node, ast.Ability) else ""
+        )
     )
     if isinstance(node, ast.Module):
         return SemScope(a, "Module", None)
-    elif isinstance(node, (ast.Enum, ast.Architype)):
+    elif isinstance(node, (ast.Enum, ast.Architype, ast.Ability)):
         node_type = (
             node.__class__.__name__
             if isinstance(node, ast.Enum)
-            else node.arch_type.value
+            else ("Ability" if isinstance(node, ast.Ability) else node.arch_type.value)
         )
         if node.parent:
-            return SemScope(a, node_type, get_sem_scope(node.parent))
+            return SemScope(
+                a,
+                node_type,
+                get_sem_scope(node.parent),
+            )
     else:
         if node.parent:
             return get_sem_scope(node.parent)

jaclang/settings.py

@@ -1,4 +1,4 @@
-"""Main settings of Jac lang."""
+"""Main settings of jac lang."""
 
 import configparser
 import os
@@ -14,10 +14,11 @@ class Settings:
     filter_sym_builtins: bool = True
     ast_symbol_info_detailed: bool = False
     pass_timer: bool = False
+    collect_py_dep_debug: bool = False
+    print_py_raised_ast: bool = False
 
-    # Import configuration
-    py_raise: bool = False
-    py_raise_deep: bool = False
+    # Formatter configuration
+    max_line_length: int = 88
 
     # LSP configuration
     lsp_debug: bool = False

jaclang/tests/fixtures/abc.jac

@@ -63,15 +63,15 @@ with entry:__main__ {
 glob expected_area = 78.53981633974483;
 
 test calc_area {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    check almostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    check almostEqual(c.area(), expected_area);
 }
 
 test circle_type {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check c.shape_type == ShapeType.CIRCLE;
 }

jaclang/tests/fixtures/access_checker.jac

@@ -1,19 +1,14 @@
-obj :priv BankAccount {
-    has account_no: int;
-    can register() {
-        print(f"{self.account_no} has been registered.");
-    }
-}
-can :priv privmethod() {
-    return "private method";
-}
-can :priv overide_check() {
-    return "inside access_check";
-}
-glob :priv b=1;
-glob :priv p=0;
+
+obj :pub  ModulePublObj {}
+obj :priv ModulePrivObj {}
+
+glob :pub  module_publ_glob:int = 0;
+glob :priv module_priv_glob:int = 0;
+
 with entry {
-    public = BankAccount(123);
-    public.register();
-    privmethod();
+    ModulePrivObj(); # <-- okey.
+    ModulePublObj(); # <-- okey.
+
+    module_publ_glob; # <-- okey.
+    module_priv_glob; # <-- okey.
 }

jaclang/tests/fixtures/access_modifier.jac

@@ -1,49 +1,104 @@
 include:jac access_checker;
-obj Animal {
-    has :pub species: str;
 
-    can :priv introduce() {
-        return "Hello, I am " + self.species + ". ";
-    }
+obj SomeObj {
+    obj :pub     InnerPublObj {}
+    obj :priv    InnerPrivObj {}
+    obj :protect InnerProtObj {}
+
+    enum :pub     InnerPublEnum { FOO = "FOO" }
+    enum :priv    InnerPrivEnum { BAR = "BAR" }
+    enum :protect InnerProtEnum { BAZ = "BAZ" }
 
+    can :pub     publ_ability() -> None {}
+    can :priv    priv_ability() -> None {}
+    can :protect prot_ability() -> None {}
 
+    has :pub     publ_attrib:int = 0;
+    has :priv    priv_attrib:int = 0;
+    has :protect prot_attrib:int = 0;
 }
 
-obj Dog: Animal: {
-    has :pub breed: str;
 
-    can init(breed: str) {
-        super.init("Dog");
-        self.breed = breed;
-    }
+obj BaseClass {
+    has :pub     publ_attrib:int = 0;
+    has :priv    priv_attrib:int = 0;
+    has :protect prot_attrib:int = 0;
 
-    can :pub bark() {
-        return "Woof! Woof!";
+    can do_base() -> None {
+        self.publ_attrib; # <-- okey.
+        self.priv_attrib; # <-- okey.
+        self.prot_attrib; # <-- okey.
     }
+}
 
-    can :pub makeSound() {
-        return "The dog says: " + super.introduce();
+
+obj DrivedClass1 :BaseClass: {
+    can do_driv1() -> None {
+        self.publ_attrib; # <-- okey.
+        self.priv_attrib; # <-- not okey.
+        self.prot_attrib; # <-- okey.
     }
-        obj Body {
-        has :pub s: str="22";
+}
+
+
+# Check if the protect works from inherited chain.
+obj DrivedClass2 :BaseClass: {
+    can do_driv2() -> None {
+        self.publ_attrib; # <-- okey.
+        self.priv_attrib; # <-- not okey.
+        self.prot_attrib; # <-- okey.
     }
 }
-can :priv overide_check() {
-    return "inside access_modifier";
+
+
+
+obj :pub Chain1 {
+    has :priv priv_val:int = 0; # <-- the private in the chain.
+}
+
+obj :pub Chain2 {
+    has :pub chain1:Chain1 = Chain1();
+}
+
+obj :pub Chain3 {
+    has :pub chain2:Chain2 = Chain2();
 }
-glob :priv a=2, c=7, m="hi";
+
+
 with entry {
-     myDog  = Dog(breed= "Golden Retriever");
-
-    print( " Name: " + myDog.species );
-    print( " Breed: " + myDog.breed );
-    print( myDog.introduce() );
-    print( myDog.bark() );
-    b=myDog.Body("33");
-    print(a);
-    account = BankAccount(3333);
-    print(privmethod());
-    print(overide_check());
-    print(b);
-    print(p);
+    SomeObj.InnerPublObj; # <-- okey.
+    SomeObj.InnerPrivObj; # <-- not okey.
+    SomeObj.InnerProtObj; # <-- not okey.
+
+    SomeObj.InnerPublEnum; # <-- okey.
+    SomeObj.InnerPrivEnum; # <-- not okey.
+    SomeObj.InnerProtEnum; # <-- not okey.
+
+    some_obj = SomeObj();
+
+    some_obj.InnerPublObj; # <-- okey.
+    some_obj.InnerPrivObj; # <-- not okey.
+    some_obj.InnerProtObj; # <-- not okey.
+
+    some_obj.InnerPublEnum; # <-- okey.
+    some_obj.InnerPrivEnum; # <-- not okey.
+    some_obj.InnerProtEnum; # <-- not okey.
+
+    some_obj.publ_attrib; # <-- okey.
+    some_obj.priv_attrib; # <-- not okey.
+    some_obj.prot_attrib; # <-- not okey.
+
+    some_obj.publ_ability(); # <-- okey.
+    some_obj.priv_ability(); # <-- not okey.
+    some_obj.prot_ability(); # <-- not okey.
+
+    chain3: Chain3 = Chain3();
+    chain3.chain2.chain1;          # <-- okey.
+    chain3.chain2.chain1.priv_val; # <-- not okey.
+
+    access_checker.ModulePublObj(); # <-- okey.
+    access_checker.ModulePrivObj(); # <-- not okey.
+
+    access_checker.module_priv_glob; # <-- okey.
+    access_checker.module_priv_glob; # <-- not okey.
 }

jaclang/tests/fixtures/baddy.jac

@@ -0,0 +1,3 @@
+can speak {
+    HasFault();
+}

jaclang/tests/fixtures/baddy.test.jac

@@ -0,0 +1,3 @@
+test baddy {
+    print(5 / 0);
+}

jaclang/tests/fixtures/bar.jac

@@ -0,0 +1,34 @@
+# Define a simple node type called `Item`
+node Item {
+    has value: int = 0;
+}
+
+# Define an edge type called `Link`
+edge Link {}
+
+# Define the `bar` walker
+walker bar_walk {
+    has count: int = 0;
+
+    # Start walking from the root node or an Item node
+    can start with `root | Item entry {
+        here ++> Item();
+        if self.count < 5 {
+            visit [-->];
+        } else {
+            "Created 5 items." |> print;
+            disengage;
+        }
+    }
+
+    # Walk over Item nodes and update their values
+    can walk with Item entry {
+        here.value = self.count;
+        f"Item value: {here.value}" |> print;
+        self.count += 1;
+        visit [-->] else {
+            "Finished walking over all items." |> print;
+            disengage;
+        }
+    }
+}

jaclang/tests/fixtures/byllmissue.jac

@@ -5,8 +5,4 @@ class Foo {
     can bar() {
         return 1;
     }
-}
-
-with entry {
-    my_thing = YourThing(level=thingy by llm());
-}
+}

jaclang/tests/fixtures/chandra_bugs2.jac

@@ -1,10 +1,13 @@
 import:py re;
 
-glob a: int=5;
+glob a: int = 5;
 
 with entry {
-    arguments = {x:None  for x in re.findall(r'\{([A-Za-z0-9_]+)\}', "Apple {apple} pineapple {pineapple}")};
-    a: int=5;
+    arguments = {x: None  for x in re.findall(
+        r'\{([A-Za-z0-9_]+)\}',
+        "Apple {apple} pineapple {pineapple}"
+    )};
+    a: int = 5;
     if False {
         with open(f"Apple{apple}.txt") as f { # Fix syntax highlighting
 
@@ -12,15 +15,13 @@ with entry {
         }
     }
     print(arguments);
-    print(
-        """This is a long
-        line of code."""
-    );
+    print("""This is a long
+    line of code.""");
 }
 
-with entry{
-    a={"a":"apple", "b":"ball", "c":"cat"};
-    y={**a, "d":"dog", "e":"elephant"};
+with entry {
+    a = {"a": "apple", "b": "ball", "c": "cat"};
+    y = {**a, "d": "dog", "e": "elephant"};
     print(y);
 }
 # Use before def error would be nice

jaclang/tests/fixtures/cls_method.jac

@@ -0,0 +1,41 @@
+"""Test file for class method."""
+
+class MyClass {
+    can simple_method() -> str {
+        return "Hello, World1!";
+    }
+
+    @classmethod
+    can my_method(cls: Type[MyClass]) -> str {
+        x = cls.__name__;
+        print(x);
+        return "Hello, World2!";
+    }
+}
+
+with entry {
+    a = MyClass.simple_method();
+    b = MyClass.my_method();
+    print(a, b);
+}
+
+class MyClass2 {
+    can Ability_1(self: MyClass2) -> str;
+    @classmethod
+    can Ability_2(cls: Type[MyClass2]) -> str;
+}
+
+:obj:MyClass2:can:Ability_1
+(self: MyClass2) -> str {
+    return "Hello, World!";
+}
+
+:obj:MyClass2:can:Ability_2 {
+    return "Hello, World22!";
+}
+
+with entry {
+    a = MyClass2().Ability_1();
+    b = MyClass2.Ability_2();
+    print(a, b);
+}

jaclang/tests/fixtures/dblhello.jac

@@ -0,0 +1,6 @@
+import hello;
+import hello;
+
+with entry {
+    hello.still_there();
+}

jaclang/tests/fixtures/deep/one_lev.jac

@@ -1,8 +1,8 @@
 import:jac from .deeper, snd_lev as snd_lev;
-import:jac from ..deep, deeper;
-import:jac from ., deeper as mydeeper;
+# import:jac from ..deep, deeper;
+# import:jac from ., deeper as mydeeper;
 
 can olprint -> str {
     # deeper.snd_lev.slprint(); FIXME:
     return "one level deeper" + snd_lev.slprint();
-}
+}

jaclang/tests/fixtures/deep/one_lev_dup.jac

@@ -1,6 +1,5 @@
-import:jac deeper.snd_lev as snd_lev;
+import:jac from .deeper, snd_lev as snd_lev;
 
-can olprint ->str {
+can olprint -> str {
     return "one level deeper" + snd_lev.slprint();
 }
-

jaclang/tests/fixtures/deep_import_mods.jac

@@ -0,0 +1,13 @@
+import:py sys;
+
+with entry {
+    before_mod = list(sys.modules.keys());
+}
+
+import:jac deep.one_lev as one_lev;
+import:jac from deep.one_lev, olprint;
+
+with entry {
+    after_mod = [m for m in sys.modules.keys() if m not in before_mod];
+    print(after_mod);
+}

jaclang/tests/fixtures/edge_node_walk.jac

@@ -37,7 +37,7 @@ edge Edge_c {
 
 with entry {
     print(root spawn creator());
-    print(root._jac_.gen_dot());
+    print(root.__jac__.gen_dot());
     print([root-:Edge_a:->]);
     print([root-:Edge_c:->]);
     print([root-:Edge_a:->-:Edge_b:->]);

jaclang/tests/fixtures/edge_ops.jac

@@ -22,7 +22,7 @@ edge MyEdge {
             for j=0 to j<3 by j+=1  {
                 end +:MyEdge:val=random.randint(1, 15), val2=random.randint(1, 5):+> node_a(value=j + 10);
             }
-            print([(i.val, i.val2) for i in end._jac_.edges if isinstance(i, MyEdge)]);
+            print([(arch.val, arch.val2) for i in end.__jac__.edges if isinstance(arch := i.architype, MyEdge)]);
         }
     }
     for i=0 to i<3 by i+=1  {

jaclang/tests/fixtures/edges_walk.jac

@@ -30,7 +30,7 @@ edge Edge_c{
 
 with entry{
     print(root spawn creator());
-    print(root._jac_.gen_dot());
+    print(root.__jac__.gen_dot());
     print([root -:Edge_a:->]);
     print([root -:Edge_c:->]);
     print([root -:Edge_a:-> -:Edge_b:->]);

jaclang/tests/fixtures/err.impl.jac

@@ -0,0 +1,3 @@
+:o:HasFault:c:init {
+    print(5 / 0);
+}