jaclang 0.7.27__py3-none-any.whl → 0.7.30__py3-none-any.whl

jaclang/compiler/passes/main/tests/fixtures/data_spatial_types.jac

@@ -0,0 +1,130 @@
+node NodeA {
+    has value: int = 10;
+}
+
+node NodeC {
+    has value: int = 10;
+}
+
+edge EdgeB {
+    has value: int = 20;
+}
+
+with entry {
+    node_1 = a(value=5);
+    node_2 = a();
+    node_3 = a(value=15);
+    node_4 = a(value=20);
+    node_5 = c(value=25);
+    print(type(root ++> node_1));
+    node_1 +:edge_1 := b(value=5):+> node_2;
+    node_1 +:edge_2 := b(value=10):+> node_3;
+    node_1 +:edge_3 := b(value=15):+> node_4;
+    node_1 +:edge_4 := b():+> node_5;
+    node_1 del--> node_2;
+    del node_3;
+}
+
+
+node A {
+    has val: int = 0;
+}
+
+edge a {}
+
+walker W {
+    can create with `root entry;
+}
+
+:walker:W:can:create {
+    Start = A(5);
+    here +:a:+> Start;
+    Start +:a:+> A(10) +:a:+> A(15);
+    Start +:a:+> A(20) +:a:+> A(25);
+}
+
+with entry {
+    root spawn W();
+    print([root-->-->(`?A)]);
+    print([root-->-->-->(`?A)]);
+}
+
+"""Bubble sort using DS Features of Jac (somparision and swapping happens in inner nodes)."""
+glob list1 = [80, 79, 60, 59, 40, 35, 19, 1];
+
+node main_node {
+    has no: int = 0;
+}
+
+node inner_node {
+    has main: int = 0,
+        sub: int = 0;
+}
+
+walker walker1 {
+    can create_main_node with `root entry;
+}
+
+:walker:walker1:can:create_main_node {
+    end = here;
+    for i=0 to i<len(list1)+1 by i+=1  {
+        end ++> (end := main_node(no=i + 1));
+        visit [-->];
+    }
+}
+
+walker walker2 {
+    can skip_root with `root entry {
+        visit [-->];
+    }
+
+    can process with main_node entry;
+}
+
+:walker:walker2:can:process {
+    :g: list1 ;
+
+    for j in range(0, len(list1) - (here.no)) {
+        here ++> inner_node(main=here.no, sub=j + 1);
+    }
+    visit [-->];
+}
+
+walker walker3 {
+    can skiproot with `root entry {
+        visit [-->];
+    }
+
+    can adjust with main_node entry;
+}
+
+:walker:walker3:can:adjust {
+    here spawn walker4();
+}
+
+walker walker4 {
+    can skipmain with main_node entry {
+        visit [-->];#  print(f"iteration {here.no} started  {list1}");
+    }
+
+    can skipin with inner_node entry {
+        :g: list1 ;
+
+        j = here.sub - 1;
+        if list1[j] > list1[j + 1] {
+            x = list1[j];
+            list1[j] = list1[j + 1];
+            list1[j + 1] = x;
+        }
+        #uncomment below to see the swap in each inner nodes
+        # print(list1);
+
+    }
+}
+
+with entry {
+    root spawn walker1();
+    root spawn walker2();
+    root spawn walker3();
+    print(Jac.node_dot(root));
+}

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/__init__.py

@@ -1,3 +1,3 @@
-from .display import *
-from .color import *
-from .constants import *
+from .display import set_mode
+from .color import Color
+from .constants import CONST_VALUE, CL

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/__init__.pyi

@@ -1,3 +1,3 @@
-from .display import *
-from .color import *
-from .constants import *
+from .display import set_mode
+from .color import Color
+from .constants import CONST_VALUE, CL

jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -81,39 +81,38 @@ class ImportPassPassTests(TestCase):
             "genericpath": r"jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi$",
         }
         for i in p:
-            self.assertIn(i, build.ir.py_raise_map)
-            self.assertRegex(re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]), p[i])
+            self.assertIn(i, build.ir.py_info.py_raise_map)
+            self.assertRegex(
+                re.sub(r".*fixtures/", "", build.ir.py_info.py_raise_map[i]).replace(
+                    "\\", "/"
+                ),
+                p[i],
+            )
 
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""
         state = jac_file_to_pass(
             self.fixture_abs_path("py_imp_test.jac"), schedule=py_code_gen_typed
         )
+        for i in list(
+            filter(
+                lambda x: x.py_info.is_raised_from_py,
+                state.ir.get_all_sub_nodes(ast.Module),
+            )
+        ):
+            print(ast.Module.get_href_path(i))
         self.assertEqual(
             len(
                 list(
                     filter(
-                        lambda x: x.is_raised_from_py,
+                        lambda x: x.py_info.is_raised_from_py,
                         state.ir.get_all_sub_nodes(ast.Module),
                     )
                 )
             ),
-            7,
+            11,  # TODO: Need to only link the modules one time
         )
 
-    # def test_py_resolve_list(self) -> None:
-    #     """Basic test for pass."""
-    #     state: JacImportPass = jac_file_to_pass(
-    #         self.examples_abs_path("rpg_game/jac_impl/jac_impl_5/main.jac"),
-    #         JacImportPass,
-    #     )
-    #     self.assertGreater(len(state.py_resolve_list), 20)
-    #     self.assertIn("pygame.sprite.Sprite.__init__", state.py_resolve_list)
-    #     self.assertIn("pygame.mouse.get_pressed", state.py_resolve_list)
-    #     self.assertIn("pygame.K_SPACE", state.py_resolve_list)
-    #     self.assertIn("random.randint", state.py_resolve_list)
-    #     self.assertIn("pygame.font.Font", state.py_resolve_list)
-
     def test_double_empty_anx(self) -> None:
         """Test importing python."""
         captured_output = io.StringIO()

jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -62,3 +62,27 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertEqual(out.count("Type: builtins.str"), 35)
         for i in lis:
             self.assertNotIn(i, out)
+
+    def test_data_spatial_type_info(self) -> None:
+        """Testing for type info for dataspatial constructs."""
+        out = AstTool().ir(
+            ["ast", f"{self.fixture_abs_path('data_spatial_types.jac')}"]
+        )
+        self.assertRegex(
+            out,
+            r"129:24 - 129:28.*SpecialVarRef - _Jac.get_root\(\) \- Type\: jaclang.runtimelib.architype.Root",
+        )
+        self.assertRegex(out, r"129:11 - 129:29.*FuncCall \- Type\: builtins\.str")
+        self.assertRegex(
+            out,
+            r"129:15 - 129:23.*Name \- node_dot \- Type\: builtins.str,  SymbolTable\: str",
+        )
+        self.assertRegex(
+            out,
+            r"128:5 - 128:25.*BinaryExpr \- Type\: jaclang.runtimelib.architype.WalkerArchitype",
+        )
+        self.assertRegex(
+            out,
+            r"48:11 - 48:28.*EdgeRefTrailer \- Type\: builtins.list\[data_spatial_types.A\]",
+        )
+        self.assertRegex(out, r"24:5 - 24:25.*BinaryExpr \- Type\: builtins.bool", out)

jaclang/compiler/passes/main/type_check_pass.py

@@ -115,13 +115,14 @@ class JacTypeCheckPass(Pass):
             for k, v in mypy_graph.items()
             if (
                 k.startswith("jaclang.plugin")
+                or k.startswith("jaclang.runtimelib")
                 or not (k.startswith("jaclang.") or k.startswith("mypy."))
             )
         }
         for i in mypy_graph:
-            self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
+            self.ir.py_info.py_mod_dep_map[i] = mypy_graph[i].xpath
             for j in mypy_graph[i].dependencies:
-                self.ir.py_mod_dep_map[j] = str(
+                self.ir.py_info.py_mod_dep_map[j] = str(
                     myab.find_module_with_reason(j, manager)
                 )
         myab.process_graph(mypy_graph, manager)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -973,7 +973,6 @@ class JacFormatPass(Pass):
                     Tok.PIPE_FWD,
                     Tok.KW_SPAWN,
                     Tok.A_PIPE_FWD,
-                    Tok.ELVIS_OP,
                 ]
                 or (
                     node.op.name == Tok.PIPE_FWD

jaclang/compiler/py_info.py

@@ -0,0 +1,22 @@
+"""Code location info for AST nodes."""
+
+from __future__ import annotations
+
+
+class PyInfo:
+    """Python info related to python imports."""
+
+    def __init__(self) -> None:
+        """Object Initialization."""
+        # Module dependacy map used to store all module dependacies detected
+        # by mypy. The dependacies are computed using the mypy graph in
+        # TypeCheck pass
+        self.py_mod_dep_map: dict[str, str] = {}
+
+        # Get all the modules that we really need to raise inorder to make
+        # all Jac types correct (FuseTypeInfo works). This is computed using
+        # PyCollectDepsPass.
+        self.py_raise_map: dict[str, str] = {}
+
+        # Flag for python modules raised into jac
+        self.is_raised_from_py: bool = False

jaclang/compiler/symtable.py

@@ -115,6 +115,7 @@ class SymbolTable:
         node: ast.AstSymbolNode,
         access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
         single: bool = False,
+        force_overwrite: bool = False,
     ) -> Optional[ast.AstNode]:
         """Set a variable in the symbol table.
 
@@ -126,7 +127,7 @@ class SymbolTable:
             if single and node.sym_name in self.tab
             else None
         )
-        if node.sym_name not in self.tab:
+        if force_overwrite or node.sym_name not in self.tab:
             self.tab[node.sym_name] = Symbol(
                 defn=node.name_spec,
                 access=(
@@ -163,11 +164,17 @@ class SymbolTable:
         node: ast.AstSymbolNode,
         access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
         single_decl: Optional[str] = None,
+        force_overwrite: bool = False,
     ) -> Optional[Symbol]:
         """Insert into symbol table."""
         if node.sym and self == node.sym.parent_tab:
             return node.sym
-        self.insert(node=node, single=single_decl is not None, access_spec=access_spec)
+        self.insert(
+            node=node,
+            single=single_decl is not None,
+            access_spec=access_spec,
+            force_overwrite=force_overwrite,
+        )
         self.update_py_ctx_for_def(node)
         return node.sym
 

jaclang/compiler/tests/test_importer.py

@@ -33,7 +33,7 @@ class TestLoader(TestCase):
         )
         self.assertIn(
             "/tests/fixtures/hello_world.jac",
-            str(JacMachine.get().loaded_modules),
+            str(JacMachine.get().loaded_modules).replace("\\\\", "/"),
         )
         JacMachine.detach()
 
@@ -62,3 +62,47 @@ class TestLoader(TestCase):
             "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
             stdout_value,
         )
+
+    def test_import_with_jacpath(self) -> None:
+        """Test module import using JACPATH."""
+        # Set up a temporary JACPATH environment variable
+        import os
+        import tempfile
+
+        jacpath_dir = tempfile.TemporaryDirectory()
+        os.environ["JACPATH"] = jacpath_dir.name
+
+        # Create a mock Jac file in the JACPATH directory
+        module_name = "test_module"
+        jac_file_path = os.path.join(jacpath_dir.name, f"{module_name}.jac")
+        with open(jac_file_path, "w") as f:
+            f.write(
+                """
+                with entry {
+                    "Hello from JACPATH!" :> print;
+                }
+                """
+            )
+
+        # Capture the output
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        try:
+            JacMachine(self.fixture_abs_path(__file__)).attach_program(
+                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            )
+            jac_import(module_name, base_path=__file__)
+            cli.run(jac_file_path)
+
+            # Reset stdout and get the output
+            sys.stdout = sys.__stdout__
+            stdout_value = captured_output.getvalue()
+
+            self.assertIn("Hello from JACPATH!", stdout_value)
+
+        finally:
+            captured_output.close()
+            JacMachine.detach()
+            os.environ.pop("JACPATH", None)
+            jacpath_dir.cleanup()

jaclang/langserve/tests/test_server.py

@@ -330,7 +330,7 @@ class TestJacLangServer(TestCase):
                     "doubleinner",
                     "apply_red",
                 ],
-                8,
+                11,
             ),
             (
                 lspt.Position(65, 23),
@@ -359,7 +359,7 @@ class TestJacLangServer(TestCase):
                     "doubleinner",
                     "apply_red",
                 ],
-                8,
+                11,
             ),
             (
                 lspt.Position(73, 22),

jaclang/plugin/default.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as ast3
 import fnmatch
 import html
+import inspect
 import os
 import types
 from collections import OrderedDict
@@ -42,8 +43,11 @@ from jaclang.runtimelib.constructs import (
 from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
 from jaclang.runtimelib.machine import JacMachine, JacProgram
 from jaclang.runtimelib.memory import Shelf, ShelfStorage
-from jaclang.runtimelib.utils import collect_node_connections, traverse_graph
-
+from jaclang.runtimelib.utils import (
+    all_issubclass,
+    collect_node_connections,
+    traverse_graph,
+)
 
 import pluggy
 
@@ -175,14 +179,12 @@ class JacAccessValidationImpl:
             if to_root.access.all > access_level:
                 access_level = to_root.access.all
 
-            level = to_root.access.roots.check(str(jroot.id))
-            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+            if (level := to_root.access.roots.check(str(jroot.id))) is not None:
                 access_level = level
 
         # if target anchor have set allowed roots
         # if current root is allowed to target anchor
-        level = to_access.roots.check(str(jroot.id))
-        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+        if (level := to_access.roots.check(str(jroot.id))) is not None:
             access_level = level
 
         return access_level
@@ -398,64 +400,85 @@ class JacWalkerImpl:
 
         walker.path = []
         walker.next = [node]
-        if walker.next:
-            current_node = walker.next[-1].architype
-            for i in warch._jac_entry_funcs_:
-                trigger = i.get_funcparam_annotations(i.func)
-                if not trigger:
-                    if i.func:
-                        i.func(warch, current_node)
-                    else:
-                        raise ValueError(f"No function {i.name} to call.")
+        current_node = node.architype
+
+        # walker entry
+        for i in warch._jac_entry_funcs_:
+            if i.func and not i.trigger:
+                i.func(warch, current_node)
+            if walker.disengaged:
+                return warch
+
         while len(walker.next):
             if current_node := walker.next.pop(0).architype:
+                # walker entry with
+                for i in warch._jac_entry_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, NodeArchitype)
+                        and isinstance(current_node, i.trigger)
+                    ):
+                        i.func(warch, current_node)
+                    if walker.disengaged:
+                        return warch
+
+                # node entry
                 for i in current_node._jac_entry_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(warch, trigger):
-                        if i.func:
-                            i.func(current_node, warch)
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+                    if i.func and not i.trigger:
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
-                for i in warch._jac_entry_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(current_node, trigger):
-                        if i.func and trigger:
-                            i.func(warch, current_node)
-                        elif not trigger:
-                            continue
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+
+                # node entry with
+                for i in current_node._jac_entry_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, WalkerArchitype)
+                        and isinstance(warch, i.trigger)
+                    ):
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
-                for i in warch._jac_exit_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(current_node, trigger):
-                        if i.func and trigger:
-                            i.func(warch, current_node)
-                        elif not trigger:
-                            continue
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+
+                # node exit with
+                for i in current_node._jac_exit_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, WalkerArchitype)
+                        and isinstance(warch, i.trigger)
+                    ):
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
+
+                # node exit
                 for i in current_node._jac_exit_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(warch, trigger):
-                        if i.func:
-                            i.func(current_node, warch)
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+                    if i.func and not i.trigger:
+                        i.func(current_node, warch)
+                    if walker.disengaged:
+                        return warch
+
+                # walker exit with
+                for i in warch._jac_exit_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, NodeArchitype)
+                        and isinstance(current_node, i.trigger)
+                    ):
+                        i.func(warch, current_node)
                     if walker.disengaged:
                         return warch
+        # walker exit
         for i in warch._jac_exit_funcs_:
-            trigger = i.get_funcparam_annotations(i.func)
-            if not trigger:
-                if i.func:
-                    i.func(warch, current_node)
-                else:
-                    raise ValueError(f"No function {i.name} to call.")
+            if i.func and not i.trigger:
+                i.func(warch, current_node)
+            if walker.disengaged:
+                return warch
+
         walker.ignores = []
         return warch
 
@@ -818,12 +841,14 @@ class JacFeatureImpl(
     @hookimpl
     def create_test(test_fun: Callable) -> Callable:
         """Create a new test."""
+        file_path = inspect.getfile(test_fun)
+        func_name = test_fun.__name__
 
         def test_deco() -> None:
             test_fun(JacTestCheck())
 
         test_deco.__name__ = test_fun.__name__
-        JacTestCheck.add_test(test_deco)
+        JacTestCheck.add_test(file_path, func_name, test_deco)
 
         return test_deco
 
@@ -831,6 +856,7 @@ class JacFeatureImpl(
     @hookimpl
     def run_test(
         filepath: str,
+        func_name: Optional[str],
         filter: Optional[str],
         xit: bool,
         maxfail: Optional[int],
@@ -849,7 +875,9 @@ class JacFeatureImpl(
                     mod_name = mod_name[:-5]
                 JacTestCheck.reset()
                 Jac.jac_import(target=mod_name, base_path=base, cachable=False)
-                JacTestCheck.run_test(xit, maxfail, verbose)
+                JacTestCheck.run_test(
+                    xit, maxfail, verbose, os.path.abspath(filepath), func_name
+                )
                 ret_count = JacTestCheck.failcount
             else:
                 print("Not a .jac file.")
@@ -875,7 +903,9 @@ class JacFeatureImpl(
                         print(f"\n\n\t\t* Inside {root_dir}" + "/" + f"{file} *")
                         JacTestCheck.reset()
                         Jac.jac_import(target=file[:-4], base_path=root_dir)
-                        JacTestCheck.run_test(xit, maxfail, verbose)
+                        JacTestCheck.run_test(
+                            xit, maxfail, verbose, os.path.abspath(file), func_name
+                        )
 
                     if JacTestCheck.breaker and (xit or maxfail):
                         break
@@ -888,12 +918,6 @@ class JacFeatureImpl(
 
         return ret_count
 
-    @staticmethod
-    @hookimpl
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        return ret if (ret := op1) is not None else op2
-
     @staticmethod
     @hookimpl
     def has_instance_default(gen_func: Callable[[], T]) -> T:
@@ -1000,7 +1024,7 @@ class JacFeatureImpl(
                         dir in [EdgeDir.OUT, EdgeDir.ANY]
                         and node == source
                         and target.architype in right
-                        and Jac.check_write_access(target)
+                        and Jac.check_connect_access(target)
                     ):
                         Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
@@ -1008,7 +1032,7 @@ class JacFeatureImpl(
                         dir in [EdgeDir.IN, EdgeDir.ANY]
                         and node == target
                         and source.architype in right
-                        and Jac.check_write_access(source)
+                        and Jac.check_connect_access(source)
                     ):
                         Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True

jaclang/plugin/feature.py

@@ -359,6 +359,7 @@ class JacFeature(
     @staticmethod
     def run_test(
         filepath: str,
+        func_name: Optional[str] = None,
         filter: Optional[str] = None,
         xit: bool = False,
         maxfail: Optional[int] = None,
@@ -368,6 +369,7 @@ class JacFeature(
         """Run the test suite in the specified .jac file."""
         return plugin_manager.hook.run_test(
             filepath=filepath,
+            func_name=func_name,
             filter=filter,
             xit=xit,
             maxfail=maxfail,
@@ -375,11 +377,6 @@ class JacFeature(
             verbose=verbose,
         )
 
-    @staticmethod
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        return plugin_manager.hook.elvis(op1=op1, op2=op2)
-
     @staticmethod
     def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""