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

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
 
@@ -398,64 +402,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 +843,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 +858,7 @@ class JacFeatureImpl(
     @hookimpl
     def run_test(
         filepath: str,
+        func_name: Optional[str],
         filter: Optional[str],
         xit: bool,
         maxfail: Optional[int],
@@ -849,7 +877,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 +905,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

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,

jaclang/plugin/spec.py

@@ -345,6 +345,7 @@ class JacFeatureSpec(
     @hookspec(firstresult=True)
     def run_test(
         filepath: str,
+        func_name: Optional[str],
         filter: Optional[str],
         xit: bool,
         maxfail: Optional[int],

jaclang/runtimelib/architype.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import inspect
 from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from enum import IntEnum
+from functools import cached_property
 from logging import getLogger
 from pickle import dumps
 from types import UnionType
@@ -220,9 +221,9 @@ class WalkerAnchor(Anchor):
     """Walker Anchor."""
 
     architype: WalkerArchitype
-    path: list[Anchor] = field(default_factory=list)
-    next: list[Anchor] = field(default_factory=list)
-    ignores: list[Anchor] = field(default_factory=list)
+    path: list[NodeAnchor] = field(default_factory=list)
+    next: list[NodeAnchor] = field(default_factory=list)
+    ignores: list[NodeAnchor] = field(default_factory=list)
     disengaged: bool = False
 
 
@@ -311,17 +312,20 @@ class DSFunc:
     name: str
     func: Callable[[Any, Any], Any] | None = None
 
+    @cached_property
+    def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
+        """Get function parameter annotations."""
+        t = (
+            (
+                inspect.signature(self.func, eval_str=True)
+                .parameters["_jac_here_"]
+                .annotation
+            )
+            if self.func
+            else None
+        )
+        return None if t is inspect._empty else t
+
     def resolve(self, cls: type) -> None:
         """Resolve the function."""
         self.func = getattr(cls, self.name)
-
-    def get_funcparam_annotations(
-        self, func: Callable[[Any, Any], Any] | None
-    ) -> type | UnionType | tuple[type | UnionType, ...] | None:
-        """Get function parameter annotations."""
-        if not func:
-            return None
-        annotation = (
-            inspect.signature(func, eval_str=True).parameters["_jac_here_"].annotation
-        )
-        return annotation if annotation != inspect._empty else None

jaclang/runtimelib/test.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import unittest
+from dataclasses import dataclass
 from typing import Callable, Optional
 
 
@@ -56,6 +57,16 @@ class JacTestCheck:
 
     test_case = unittest.TestCase()
     test_suite = unittest.TestSuite()
+
+    @dataclass
+    class TestSuite:
+        """Test Suite."""
+
+        test_case: unittest.FunctionTestCase
+        func_name: str
+
+    test_suite_path: dict[str, list[TestSuite]] = {}
+
     breaker = False
     failcount = 0
 
@@ -64,13 +75,45 @@ class JacTestCheck:
         """Clear the test suite."""
         JacTestCheck.test_case = unittest.TestCase()
         JacTestCheck.test_suite = unittest.TestSuite()
+        JacTestCheck.test_suite_path = {}
 
     @staticmethod
-    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None:
+    def run_test(
+        xit: bool,
+        maxfail: int | None,
+        verbose: bool,
+        filepath: str | None,
+        func_name: str | None,
+    ) -> None:
         """Run the test suite."""
         verb = 2 if verbose else 1
+        test_suite = JacTestCheck.test_suite
+
+        if filepath and filepath.endswith(".test.jac"):
+            filepath = filepath[:-9]
+        elif filepath and filepath.endswith(".jac"):
+            filepath = filepath[:-4]
+
+        if filepath:
+            test_cases = JacTestCheck.test_suite_path.get(filepath)
+            if test_cases is not None:
+                test_suite = unittest.TestSuite()
+                for test_case in test_cases:
+                    if func_name:
+                        if test_case.func_name == func_name:
+                            test_suite.addTest(test_case.test_case)
+                    else:
+                        test_suite.addTest(test_case.test_case)
+
+        elif func_name:
+            test_suite = unittest.TestSuite()
+            for test_cases in JacTestCheck.test_suite_path.values():
+                for test_case in test_cases:
+                    if test_case.func_name == func_name:
+                        test_suite.addTest(test_case.test_case)
+
         runner = JacTextTestRunner(max_failures=maxfail, failfast=xit, verbosity=verb)
-        result = runner.run(JacTestCheck.test_suite)
+        result = runner.run(test_suite)
         if result.wasSuccessful():
             print("Passed successfully.")
         else:
@@ -81,9 +124,21 @@ class JacTestCheck:
             )
 
     @staticmethod
-    def add_test(test_fun: Callable) -> None:
+    def add_test(filepath: str, func_name: str, test_func: Callable) -> None:
         """Create a new test."""
-        JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
+        if filepath and filepath.endswith(".test.jac"):
+            filepath = filepath[:-9]
+        elif filepath and filepath.endswith(".jac"):
+            filepath = filepath[:-4]
+
+        if filepath not in JacTestCheck.test_suite_path:
+            JacTestCheck.test_suite_path[filepath] = []
+
+        test_case = unittest.FunctionTestCase(test_func)
+        JacTestCheck.test_suite_path[filepath].append(
+            JacTestCheck.TestSuite(test_case=test_case, func_name=func_name)
+        )
+        JacTestCheck.test_suite.addTest(test_case)
 
     def __getattr__(self, name: str) -> object:
         """Make convenient check.Equal(...) etc."""

jaclang/runtimelib/utils.py

@@ -231,3 +231,18 @@ def is_instance(
             return isinstance(obj, target)
         case _:
             return False
+
+
+def all_issubclass(
+    classes: type | UnionType | tuple[type | UnionType, ...], target: type
+) -> bool:
+    """Check if all classes is subclass of target type."""
+    match classes:
+        case type():
+            return issubclass(classes, target)
+        case UnionType():
+            return all((all_issubclass(cls, target) for cls in classes.__args__))
+        case tuple():
+            return all((all_issubclass(cls, target) for cls in classes))
+        case _:
+            return False

jaclang/settings.py

@@ -16,10 +16,13 @@ class Settings:
     pass_timer: bool = False
     collect_py_dep_debug: bool = False
     print_py_raised_ast: bool = False
+    py_import_pass_debug: bool = False
+    inherit_pass_debug: bool = False
 
     # Compiler configuration
     disable_mtllm: bool = False
     ignore_test_annex: bool = False
+    allow_import_from: bool = False
 
     # Formatter configuration
     max_line_length: int = 88

jaclang/tests/fixtures/base_class1.jac

@@ -0,0 +1,11 @@
+import:py test_py;
+
+class B :test_py.A: {}
+
+with entry {
+    a = test_py.A();
+    b = B();
+
+    a.start();
+    b.start();
+}

jaclang/tests/fixtures/base_class2.jac

@@ -0,0 +1,11 @@
+import:py from test_py { A }
+
+class B :A: {}
+
+with entry {
+    a = A();
+    b = B();
+
+    a.start();
+    b.start();
+}

jaclang/tests/fixtures/import_all.jac

@@ -0,0 +1,7 @@
+import:py import_all_py;
+
+with entry {
+    print(import_all_py.custom_func(11));
+    print(import_all_py.pi);
+    print(import_all_py.floor(0.5));
+}

jaclang/tests/fixtures/import_all_py.py

@@ -0,0 +1,8 @@
+"""Module used for testing from x import * in jac."""
+
+from math import *  # noqa
+
+
+def custom_func(x: int) -> str:
+    """Dummy custom function for testing purposes."""  # noqa
+    return str(x)

jaclang/tests/fixtures/jactest_imported.jac

@@ -0,0 +1,6 @@
+
+
+test this_should_not_run {
+    print("This test should not run after import.");
+    assert False;
+}

jaclang/tests/fixtures/jactest_main.jac

@@ -0,0 +1,22 @@
+import jactest_imported;
+
+can fib(n: int) -> int {
+    if n <= 1 {
+        return n;
+    }
+    return fib(n - 1) + fib(n - 2);
+}
+
+
+test first_two {
+    print("Testing first 2 fibonacci numbers.");
+    assert fib(0) == 0;
+    assert fib(1) == 0;
+}
+
+test from_2_to_10 {
+    print("Testing fibonacci numbers from 2 to 10.");
+    for i in range(2, 10) {
+        assert fib(i) == fib(i - 1) + fib(i - 2);
+    }
+}

jaclang/tests/fixtures/multi_dim_array_split.jac

@@ -1,13 +1,9 @@
-import:py numpy as np;
-
 with entry {
-    arr = np.array(
-        [[1,   2,  3,  4,  5],
+    arr = [[1,   2,  3,  4,  5],
          [6,   7,  8,  9, 10],
          [11, 12, 13, 14, 15],
          [16, 17, 18, 19, 20],
-         [21, 22, 23, 24, 25]]
-    );
+         [21, 22, 23, 24, 25]];
 
     print('Original Array:');
     print(arr);

jaclang/tests/fixtures/test_py.py

@@ -0,0 +1,12 @@
+"""Test file for subclass issue."""
+
+p = 5
+g = 6
+
+
+class A:
+    """Dummy class to test the base class issue."""
+
+    def start(self) -> int:
+        """Return 0."""
+        return 0

jaclang/tests/fixtures/visit_sequence.jac

@@ -0,0 +1,50 @@
+node Node {
+    has val: str;
+
+    can entry1 with entry {
+        print(f"{self.val}-2");
+    }
+
+    can entry2 with Walker entry {
+        print(f"{self.val}-3");
+    }
+
+    can exit1 with Walker exit {
+        print(f"{self.val}-4");
+    }
+
+    can exit2 with exit {
+        print(f"{self.val}-5");
+    }
+}
+
+walker Walker {
+    can entry1 with entry {
+        print("walker entry");
+    }
+
+    can entry2 with `root entry {
+        print("walker enter to root");
+        visit [-->];
+    }
+
+    can entry3 with Node entry {
+        print(f"{here.val}-1");
+    }
+
+    can exit1 with Node exit {
+        print(f"{here.val}-6");
+    }
+
+    can exit2 with exit {
+        print("walker exit");
+    }
+}
+
+with entry{
+    root ++> Node(val = "a");
+    root ++> Node(val = "b");
+    root ++> Node(val = "c");
+
+    Walker() spawn root;
+}

jaclang/tests/test_cli.py

@@ -233,6 +233,67 @@ class JacCliTests(TestCase):
             r"13\:12 \- 13\:18.*Name - append - .*SymbolPath: builtins_test.builtins.list.append",
         )
 
+    def test_import_all(self) -> None:
+        """Testing for print AstTool."""
+        from jaclang.settings import settings
+
+        settings.ast_symbol_info_detailed = True
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('import_all.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        settings.ast_symbol_info_detailed = False
+
+        self.assertRegex(
+            stdout_value,
+            r"6\:25 - 6\:30.*Name - floor -.*SymbolPath: import_all.import_all_py.floor",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"5\:25 - 5\:27.*Name - pi -.*SymbolPath: import_all.import_all_py.pi",
+        )
+
+    def test_sub_class_symbol_table_fix_1(self) -> None:
+        """Testing for print AstTool."""
+        from jaclang.settings import settings
+
+        settings.ast_symbol_info_detailed = True
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('base_class1.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        settings.ast_symbol_info_detailed = False
+
+        self.assertRegex(
+            stdout_value,
+            r"10:7 - 10:12.*Name - start - Type.*SymbolPath: base_class1.B.start",
+        )
+
+    def test_sub_class_symbol_table_fix_2(self) -> None:
+        """Testing for print AstTool."""
+        from jaclang.settings import settings
+
+        settings.ast_symbol_info_detailed = True
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('base_class2.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        settings.ast_symbol_info_detailed = False
+
+        self.assertRegex(
+            stdout_value,
+            r"10:7 - 10:12.*Name - start - Type.*SymbolPath: base_class2.B.start",
+        )
+
     def test_expr_types(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -393,6 +454,27 @@ class JacCliTests(TestCase):
         self.assertIn("...F", stderr)
         self.assertIn("F.F", stderr)
 
+    def test_run_specific_test_only(self) -> None:
+        """Test a specific test case."""
+        process = subprocess.Popen(
+            [
+                "jac",
+                "test",
+                "-t",
+                "from_2_to_10",
+                self.fixture_abs_path("jactest_main.jac"),
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Ran 1 test", stderr)
+        self.assertIn("Testing fibonacci numbers from 2 to 10.", stdout)
+        self.assertNotIn("Testing first 2 fibonacci numbers.", stdout)
+        self.assertNotIn("This test should not run after import.", stdout)
+
     def test_graph_coverage(self) -> None:
         """Test for coverage of graph cmd."""
         graph_params = set(inspect.signature(cli.dot).parameters.keys())