jaclang 0.7.26__py3-none-any.whl → 0.7.28__py3-none-any.whl

jaclang/plugin/tests/fixtures/other_root_access.jac

@@ -23,6 +23,16 @@ walker update_node {
     }
 }
 
+walker update_target_node {
+    has val: int;
+    has node_id: str;
+
+    can enter with `root entry {
+        target_node = &(self.node_id);
+        target_node.val = self.val;
+    }
+}
+
 walker update_node_forced {
     has val: int;
 

jaclang/plugin/tests/fixtures/savable_object.jac

@@ -0,0 +1,84 @@
+enum Enum {
+    A = "a",
+    B = "b",
+    C = "c"
+}
+
+obj Child {
+    has val: int, arr: list[int], json: dict[str, int], enum_field: Enum;
+}
+
+obj Parent:Child: {
+    has child: Child;
+}
+
+obj SavableObject {
+    has val: int, arr: list[int], json: dict[str, int], parent: Parent, enum_field: Enum;
+}
+
+walker create_custom_object {
+    can enter1 with `root entry {
+        o = SavableObject(
+            val=0,
+            arr=[],
+            json={},
+            parent=Parent(
+                val=1,
+                arr=[1],
+                json={"a": 1},
+                child=Child(
+                    val=2,
+                    arr=[1, 2],
+                    json={"a": 1, "b": 2},
+                    enum_field = Enum.C
+                ),
+                enum_field = Enum.B
+            ),
+            enum_field = Enum.A
+        );
+        Jac.save(o);
+        print(jid(o));
+        print(o);
+    }
+}
+
+walker get_custom_object {
+    has object_id: str;
+
+    can enter1 with `root entry {
+        try {
+            print(&(self.object_id));
+        } except Exception as e {
+            print(None);
+        }
+    }
+}
+
+walker update_custom_object {
+    has object_id: str;
+
+    can enter1 with `root entry {
+        savable_object = &(self.object_id);
+        savable_object.parent.child.json["c"] = 3;
+        savable_object.parent.child.arr.append(3);
+        savable_object.parent.child.val = 3;
+        savable_object.parent.child.enum_field = Enum.A;
+        savable_object.parent.json["b"] = 2;
+        savable_object.parent.arr.append(2);
+        savable_object.parent.val = 2;
+        savable_object.parent.enum_field = Enum.C;
+        savable_object.json["a"] = 1;
+        savable_object.arr.append(1);
+        savable_object.val = 1;
+        savable_object.enum_field = Enum.B;
+        print(savable_object);
+    }
+}
+
+walker delete_custom_object {
+    has object_id: str;
+
+    can enter1 with `root entry {
+        Jac.destroy(&(self.object_id));
+    }
+}

jaclang/plugin/tests/test_jaseci.py

@@ -385,6 +385,22 @@ class TestJaseciPlugin(TestCase):
             node=self.nodes[0],
         )
 
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_target_node",
+            args=[20, self.nodes[1]],
+            session=session,
+            root=self.roots[0],
+        )
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_target_node",
+            args=[10, self.nodes[0]],
+            session=session,
+            root=self.roots[1],
+        )
+
         cli.enter(
             filename=self.fixture_abs_path("other_root_access.jac"),
             entrypoint="check_node",
@@ -728,3 +744,75 @@ class TestJaseciPlugin(TestCase):
         )
 
         self._del_session(session)
+
+    def test_savable_object(self) -> None:
+        """Test ObjectAnchor save."""
+        global session
+        session = self.fixture_abs_path("other_root_access.session")
+
+        self._output2buffer()
+
+        cli.enter(
+            filename=self.fixture_abs_path("savable_object.jac"),
+            entrypoint="create_custom_object",
+            args=[],
+            session=session,
+        )
+
+        prints = self.capturedOutput.getvalue().strip().split("\n")
+        id = prints[0]
+
+        self.assertEqual(
+            "SavableObject(val=0, arr=[], json={}, parent=Parent(val=1, arr=[1], json"
+            "={'a': 1}, enum_field=<Enum.B: 'b'>, child=Child(val=2, arr=[1, 2], json"
+            "={'a': 1, 'b': 2}, enum_field=<Enum.C: 'c'>)), enum_field=<Enum.A: 'a'>)",
+            prints[1],
+        )
+
+        self._output2buffer()
+
+        cli.enter(
+            filename=self.fixture_abs_path("savable_object.jac"),
+            entrypoint="get_custom_object",
+            args=[id],
+            session=session,
+        )
+        self.assertEqual(
+            "SavableObject(val=0, arr=[], json={}, parent=Parent(val=1, arr=[1], json"
+            "={'a': 1}, enum_field=<Enum.B: 'b'>, child=Child(val=2, arr=[1, 2], json"
+            "={'a': 1, 'b': 2}, enum_field=<Enum.C: 'c'>)), enum_field=<Enum.A: 'a'>)",
+            self.capturedOutput.getvalue().strip(),
+        )
+
+        self._output2buffer()
+
+        cli.enter(
+            filename=self.fixture_abs_path("savable_object.jac"),
+            entrypoint="update_custom_object",
+            args=[id],
+            session=session,
+        )
+
+        self.assertEqual(
+            "SavableObject(val=1, arr=[1], json={'a': 1}, parent=Parent(val=2, arr=[1, 2], json"
+            "={'a': 1, 'b': 2}, enum_field=<Enum.C: 'c'>, child=Child(val=3, arr=[1, 2, 3], json"
+            "={'a': 1, 'b': 2, 'c': 3}, enum_field=<Enum.A: 'a'>)), enum_field=<Enum.B: 'b'>)",
+            self.capturedOutput.getvalue().strip(),
+        )
+
+        self._output2buffer()
+
+        cli.enter(
+            filename=self.fixture_abs_path("savable_object.jac"),
+            entrypoint="delete_custom_object",
+            args=[id],
+            session=session,
+        )
+
+        cli.enter(
+            filename=self.fixture_abs_path("savable_object.jac"),
+            entrypoint="get_custom_object",
+            args=[id],
+            session=session,
+        )
+        self.assertEqual("None", self.capturedOutput.getvalue().strip())

jaclang/runtimelib/architype.py

@@ -226,6 +226,13 @@ class WalkerAnchor(Anchor):
     disengaged: bool = False
 
 
+@dataclass(eq=False, repr=False, kw_only=True)
+class ObjectAnchor(Anchor):
+    """Edge Anchor."""
+
+    architype: ObjectArchitype
+
+
 class Architype:
     """Architype Protocol."""
 
@@ -267,6 +274,16 @@ class WalkerArchitype(Architype):
         self.__jac__ = WalkerAnchor(architype=self)
 
 
+class ObjectArchitype(Architype):
+    """Walker Architype Protocol."""
+
+    __jac__: ObjectAnchor
+
+    def __init__(self) -> None:
+        """Create walker architype."""
+        self.__jac__ = ObjectAnchor(architype=self)
+
+
 @dataclass(eq=False)
 class GenericEdge(EdgeArchitype):
     """Generic Root Node."""

jaclang/runtimelib/memory.py

@@ -84,14 +84,32 @@ class ShelfStorage(Memory[UUID, Anchor]):
     def close(self) -> None:
         """Close memory handler."""
         if isinstance(self.__shelf__, Shelf):
-            from jaclang.plugin.feature import JacFeature as Jac
-
             for anchor in self.__gc__:
                 self.__shelf__.pop(str(anchor.id), None)
                 self.__mem__.pop(anchor.id, None)
 
-            for d in self.__mem__.values():
-                if d.persistent and d.hash != hash(dumps(d)):
+            keys = set(self.__mem__.keys())
+
+            # current memory
+            self.sync_mem_to_db(keys)
+
+            # additional after memory sync
+            self.sync_mem_to_db(set(self.__mem__.keys() - keys))
+
+            self.__shelf__.close()
+        super().close()
+
+    def sync_mem_to_db(self, keys: Iterable[UUID]) -> None:
+        """Manually sync memory to db."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
+        if isinstance(self.__shelf__, Shelf):
+            for key in keys:
+                if (
+                    (d := self.__mem__.get(key))
+                    and d.persistent
+                    and d.hash != hash(dumps(d))
+                ):
                     _id = str(d.id)
                     if p_d := self.__shelf__.get(_id):
                         if (
@@ -119,9 +137,6 @@ class ShelfStorage(Memory[UUID, Anchor]):
                     ):
                         self.__shelf__[_id] = d
 
-            self.__shelf__.close()
-        super().close()
-
     def find(
         self,
         ids: UUID | Iterable[UUID],

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

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as ast3
 import sys
 from contextlib import contextmanager
+from types import UnionType
 from typing import Callable, Iterator, TYPE_CHECKING
 
 import jaclang.compiler.absyntree as ast
@@ -215,3 +216,18 @@ def extract_params(
                             )
                             exclude_info.append((var_name, i.gen.py_ast[0]))
     return model_params, include_info, exclude_info
+
+
+def is_instance(
+    obj: object, target: type | UnionType | tuple[type | UnionType, ...]
+) -> bool:
+    """Check if object is instance of target type."""
+    match target:
+        case UnionType():
+            return any((is_instance(obj, trg) for trg in target.__args__))
+        case tuple():
+            return any((is_instance(obj, trg) for trg in target))
+        case type():
+            return isinstance(obj, target)
+        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/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())

jaclang/tests/test_language.py

@@ -117,11 +117,10 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
 
-        # print(arr[1:3, 1::2]);
         expected_outputs = [
-            "+-- AtomTrailer - Type: Any",
-            "    +-- Name - arr - Type: Any,  SymbolTable: None",
-            "    +-- IndexSlice - [IndexSlice] - Type: builtins.slice,  SymbolTable: None",
+            "+-- AtomTrailer - Type: builtins.list[builtins.int]",
+            "    +-- Name - arr - Type: builtins.list[builtins.list[builtins.int]],  SymbolTable: list",
+            "    +-- IndexSlice - [IndexSlice] - Type: builtins.list[builtins.list[builtins.int]],  SymbolTable: None",
             "        +-- Token - [,",
             "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
             "        +-- Token - :,",
@@ -549,7 +548,7 @@ class JacLanguageTests(TestCase):
                 return f"Error While Jac to Py AST conversion: {e}"
 
         ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
-        self.assertEqual(len(ir.get_all_sub_nodes(ast.Architype)), 7)
+        self.assertEqual(len(ir.get_all_sub_nodes(ast.Architype)), 21)
         captured_output = io.StringIO()
         sys.stdout = captured_output
         jac_import("needs_import_1", base_path=self.fixture_abs_path("./"))
@@ -612,7 +611,7 @@ class JacLanguageTests(TestCase):
 
         ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
         self.assertEqual(
-            len(ir.get_all_sub_nodes(ast.Architype)), 8
+            len(ir.get_all_sub_nodes(ast.Architype)), 27
         )  # Because of the Architype from math
         captured_output = io.StringIO()
         sys.stdout = captured_output
@@ -666,7 +665,7 @@ class JacLanguageTests(TestCase):
 
         ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
         self.assertEqual(
-            len(ir.get_all_sub_nodes(ast.Architype)), 38
+            len(ir.get_all_sub_nodes(ast.Architype)), 75
         )  # Because of the Architype from other imports
         captured_output = io.StringIO()
         sys.stdout = captured_output
@@ -874,7 +873,7 @@ class JacLanguageTests(TestCase):
         ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
         jac_ast = ir.pp()
         self.assertIn(" |   +-- String - 'Loop completed normally{}'", jac_ast)
-        self.assertEqual(len(ir.get_all_sub_nodes(ast.SubNodeList)), 269)
+        self.assertEqual(len(ir.get_all_sub_nodes(ast.SubNodeList)), 586)
         captured_output = io.StringIO()
         sys.stdout = captured_output
         jac_import("deep_convert", base_path=self.fixture_abs_path("./"))

jaclang/utils/helpers.py

@@ -165,7 +165,15 @@ def dump_traceback(e: Exception) -> str:
             (frame.lineno is not None) and frame.line and frame.line.strip() != ""
         ):
 
-            line_o = frame._original_line.rstrip()  # type: ignore [attr-defined]
+            # Note: This is CPython internals we're trying to get since python doesn't provide
+            # the frames original line but the stripped version so we had to do this.
+            line_o = frame.line  # Fallback line.
+            if hasattr(frame, "_original_line"):
+                line_o = frame._original_line.rstrip()  # type: ignore [attr-defined]
+            elif hasattr(frame, "_original_lines"):
+                # https://github.com/python/cpython/issues/106922
+                line_o = frame._original_lines.split("\n")[0].rstrip()  # type: ignore [attr-defined]
+
             if frame.colno is not None and frame.end_colno is not None:
                 off_start = byte_offset_to_char_offset(line_o, frame.colno) - 1
                 off_end = byte_offset_to_char_offset(line_o, frame.end_colno) - 1