jaclang 0.7.23__py3-none-any.whl → 0.7.25__py3-none-any.whl

jaclang/tests/fixtures/expr_type.jac

@@ -0,0 +1,54 @@
+with entry {
+    a = 4;
+    b = 7;
+    c = a + b; # OpExpr.
+    d = a + b + c;
+
+    h = float(a); # CallExpr.
+
+    (1 < 2);  # ComparisonExpr.
+    ('a' + 'b').upper(); # CallExpr.
+    [1,2][0]; # IndexExpr.
+    not False; # UnaryExpr.
+    "a" if True else "b"; # ConditionalExpr.
+    [i for i in range(10)]; # ListComprehension.
+}
+
+# Remaining expressions to test:
+# AssertTypeExpr,
+# AssignmentExpr,
+# AwaitExpr,
+# BytesExpr,
+# CastExpr,
+# ComplexExpr,
+# DictionaryComprehension,
+# DictExpr,
+# EllipsisExpr,
+# EnumCallExpr,
+# Expression,
+# FloatExpr,
+# GeneratorExpr,
+# IntExpr,
+# LambdaExpr,
+# ListExpr,
+# MemberExpr,
+# NamedTupleExpr,
+# NameExpr,
+# NewTypeExpr,
+# ParamSpecExpr,
+# PromoteExpr,
+# RefExpr,
+# RevealExpr,
+# SetComprehension,
+# SetExpr,
+# SliceExpr,
+# StarExpr,
+# StrExpr,
+# SuperExpr,
+# TupleExpr,
+# TypeAliasExpr,
+# TypedDictExpr,
+# TypeVarExpr,
+# TypeVarTupleExpr,
+# YieldExpr,
+# YieldFromExpr,

jaclang/tests/fixtures/glob_multivar_statement.jac

@@ -0,0 +1,15 @@
+glob a: str, b: str;
+glob c: str;
+
+can do() {
+    :g: a, b, c ;
+
+    (a, b, c) = ("Welcome", "to", "Jaseci!");
+}
+
+with entry {
+    (a, b, c) = ("Hello", "World", "!");
+    print(a, b, c);
+    do();
+    print(a, b, c);
+}

jaclang/tests/fixtures/registry.jac

@@ -13,16 +13,16 @@ Person {
 
 enum 'Personality of the Person'
 Personality {
-   INTROVERT: 'Person who is shy and reticent' = 9,
-   EXTROVERT: 'Person who is outgoing and socially confident'
+    INTROVERT: 'Person who is shy and reticent' = 9,
+    EXTROVERT: 'Person who is outgoing and socially confident'
 }
 
-glob personality_examples: 'Personality Information of Famous People': dict[str, Personality|None] = {
+glob personality_examples: 'Personality Information of Famous People': dict[str, Personality | None] = {
     'Albert Einstein': Personality.INTROVERT,
     'Barack Obama': Personality.EXTROVERT
 };
 
-glob person_value : list[tuple[dict[str, Personality], int]] =(-90);
+glob person_value: list[tuple[dict[str, Personality], int]] = (-90);
 
 can 'GenAI ability'
 genai_ability(x: 'Something': str) -> 'Something Else': str by llm();
@@ -34,13 +34,25 @@ normal_ability(x: 'Something': str) -> 'Something Else': str {
 }
 
 can foo() {
-   person_value=22;
-   can bar() {
-       person_value=33;
-   }
+    person_value = 22;
+    can bar() {
+        person_value = 33;
+    }
 }
 with entry {
     einstein_age: int = 75;
     einstein_age += 1;
     einstein = Person('Albert Einstein', einstein_age);
 }
+
+import from jaclang.runtimelib.machine { JacMachine }
+
+with entry {
+    registry = JacMachine.get().jac_program.sem_ir;
+
+    print(len(registry.registry));
+    print(len(list(registry.registry.items())[0][1]));
+    print(list(registry.registry.items())[3][0].scope);
+    (_, sem_info) = registry.lookup(name="normal_ability");
+    print(len(sem_info.get_children(registry)));
+}

jaclang/tests/main.jac

@@ -0,0 +1,2 @@
+import foo;
+

jaclang/tests/test_cli.py

@@ -1,5 +1,6 @@
 """Test Jac cli module."""
 
+import contextlib
 import inspect
 import io
 import os
@@ -55,10 +56,8 @@ class JacCliTests(TestCase):
         sys.stdout = captured_output
         sys.stderr = captured_output
 
-        try:
+        with contextlib.suppress(Exception):
             cli.run(self.fixture_abs_path("err_runtime.jac"))
-        except Exception as e:
-            print(f"Error: {e}")
 
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
@@ -71,7 +70,6 @@ class JacCliTests(TestCase):
             "  at foo() ",
             "  at <module> ",
         )
-
         logger_capture = "\n".join([rec.message for rec in self.caplog.records])
         for exp in expected_stdout_values:
             self.assertIn(exp, logger_capture)
@@ -217,6 +215,42 @@ class JacCliTests(TestCase):
             r"13\:12 \- 13\:18.*Name - append - .*SymbolPath: builtins_test.builtins.list.append",
         )
 
+    def test_expr_types(self) -> None:
+        """Testing for print AstTool."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('expr_type.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertRegex(
+            stdout_value, r"4\:9 \- 4\:14.*BinaryExpr \- Type\: builtins.int"
+        )
+        self.assertRegex(
+            stdout_value, r"7\:9 \- 7\:17.*FuncCall \- Type\: builtins.float"
+        )
+        self.assertRegex(
+            stdout_value, r"9\:6 \- 9\:11.*CompareExpr \- Type\: builtins.bool"
+        )
+        self.assertRegex(
+            stdout_value, r"10\:6 - 10\:15.*BinaryExpr \- Type\: builtins.str"
+        )
+        self.assertRegex(
+            stdout_value, r"11\:5 \- 11\:13.*AtomTrailer \- Type\: builtins.int"
+        )
+        self.assertRegex(
+            stdout_value, r"12\:5 \- 12\:14.*UnaryExpr \- Type\: builtins.bool"
+        )
+        self.assertRegex(
+            stdout_value, r"13\:5 \- 13\:25.*IfElseExpr \- Type\: Literal\['a']\?"
+        )
+        self.assertRegex(
+            stdout_value,
+            r"14\:5 \- 14\:27.*ListCompr - \[ListCompr] \- Type\: builtins.list\[builtins.int]",
+        )
+
     def test_ast_dotgen(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -247,6 +281,8 @@ class JacCliTests(TestCase):
         self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 7)
         self.assertEqual(stdout_value.count("builtins.int"), 3)
         self.assertEqual(stdout_value.count("builtins.str"), 10)
+        self.assertIn("Literal['test_server']", stdout_value)
+        self.assertIn("Literal['1']", stdout_value)
 
     def test_build_and_run(self) -> None:
         """Testing for print AstTool."""
@@ -368,3 +404,31 @@ class JacCliTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("can my_print(x: object) -> None", stdout_value)
+
+    def test_caching_issue(self) -> None:
+        """Test for Caching Issue."""
+        test_file = self.fixture_abs_path("test_caching_issue.jac")
+        test_cases = [(10, True), (11, False)]
+        for x, is_passed in test_cases:
+            with open(test_file, "w") as f:
+                f.write(
+                    f"""
+                test mytest{{
+                    check 10 == {x};
+                }}
+                """
+                )
+            process = subprocess.Popen(
+                ["jac", "test", test_file],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            stdout, stderr = process.communicate()
+            if is_passed:
+                self.assertIn("Passed successfully.", stdout)
+                self.assertIn(".", stderr)
+            else:
+                self.assertNotIn("Passed successfully.", stdout)
+                self.assertIn("F", stderr)
+        os.remove(test_file)

jaclang/tests/test_language.py

@@ -2,7 +2,6 @@
 
 import io
 import os
-import pickle
 import sys
 import sysconfig
 
@@ -24,7 +23,7 @@ class JacLanguageTests(TestCase):
         """Set up test."""
         SUPER_ROOT_ANCHOR.edges.clear()
         JacMachine(self.fixture_abs_path("./")).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         return super().setUp()
 
@@ -209,8 +208,10 @@ class JacLanguageTests(TestCase):
         """Test semstring."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
+        sys.stderr = captured_output
         jac_import("semstr", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         self.assertNotIn("Error", stdout_value)
 
@@ -237,6 +238,7 @@ class JacLanguageTests(TestCase):
         self.assertEqual(stdout_value.split("\n")[0], "11 13 12 12 11 12 12")
         self.assertEqual(stdout_value.split("\n")[1], '12 12 """hello"""  18 18')
         self.assertEqual(stdout_value.split("\n")[2], "11 12 11 12 11 18 23")
+        self.assertEqual(stdout_value.split("\n")[3], 'hello klkl"""')
 
     def test_deep_imports(self) -> None:
         """Parse micro jac file."""
@@ -465,24 +467,22 @@ class JacLanguageTests(TestCase):
         """Test Jac registry feature."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
+        sys.stderr = captured_output
         jac_import("registry", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         self.assertNotIn("Error", stdout_value)
 
-        with open(
-            os.path.join(
-                self.fixture_abs_path("./"), "__jac_gen__", "registry.registry.pkl"
-            ),
-            "rb",
-        ) as f:
-            registry = pickle.load(f)
+        output_lines = stdout_value.strip().split("\n")
+        outputs = [
+            int(output_lines[i]) if i != 2 else output_lines[i] for i in range(4)
+        ]
 
-        self.assertEqual(len(registry.registry), 9)
-        self.assertEqual(len(list(registry.registry.items())[0][1]), 2)
-        self.assertEqual(list(registry.registry.items())[3][0].scope, "Person")
-        _, sem_info = registry.lookup(name="normal_ability")
-        self.assertEqual(len(sem_info.get_children(registry)), 2)
+        self.assertEqual(outputs[0], 9)
+        self.assertEqual(outputs[1], 2)
+        self.assertEqual(outputs[2], "Person")
+        self.assertEqual(outputs[3], 2)
 
     def test_enum_inside_arch(self) -> None:
         """Test Enum as member stmt."""
@@ -491,7 +491,7 @@ class JacLanguageTests(TestCase):
         jac_import("enum_inside_archtype", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual("2\n", stdout_value)
+        self.assertIn("2 Accessing privileged Data", stdout_value)
 
     def test_needs_import_1(self) -> None:
         """Test py ast to Jac ast conversion output."""
@@ -503,10 +503,13 @@ class JacLanguageTests(TestCase):
         import jaclang.compiler.absyntree as ast
 
         with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
+            file_source = f.read()
+            parsed_ast = py_ast.parse(file_source)
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast, orig_src=ast.JacSource(file_source, file_name)
+                    ),
                 )
             except Exception as e:
                 return f"Error While Jac to Py AST conversion: {e}"
@@ -528,9 +531,11 @@ class JacLanguageTests(TestCase):
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_1.py")
         with open(py_out_path) as f:
+            file_source = f.read()
             output = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(
-                    py_ast.parse(f.read()), mod_path=py_out_path
+                    py_ast.parse(file_source),
+                    orig_src=ast.JacSource(file_source, py_out_path),
                 ),
             ).ir.unparse()
         # print(output)
@@ -559,10 +564,14 @@ class JacLanguageTests(TestCase):
         import jaclang.compiler.absyntree as ast
 
         with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
+            file_source = f.read()
+            parsed_ast = py_ast.parse(file_source)
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast,
+                        orig_src=ast.JacSource(file_source, file_name),
+                    ),
                 )
             except Exception as e:
                 return f"Error While Jac to Py AST conversion: {e}"
@@ -587,9 +596,11 @@ class JacLanguageTests(TestCase):
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_2.py")
         with open(py_out_path) as f:
+            file_source = f.read()
             output = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(
-                    py_ast.parse(f.read()), mod_path=py_out_path
+                    py_ast.parse(file_source),
+                    orig_src=ast.JacSource(file_source, py_out_path),
                 ),
             ).ir.unparse()
         self.assertIn("class X {\n    with entry {\n\n        a_b = 67;", output)
@@ -607,10 +618,14 @@ class JacLanguageTests(TestCase):
         import jaclang.compiler.absyntree as ast
 
         with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
+            file_source = f.read()
+            parsed_ast = py_ast.parse(file_source)
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast,
+                        orig_src=ast.JacSource(file_source, file_name),
+                    ),
                 )
             except Exception as e:
                 return f"Error While Jac to Py AST conversion: {e}"
@@ -634,9 +649,11 @@ class JacLanguageTests(TestCase):
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_3.py")
         with open(py_out_path) as f:
+            file_source = f.read()
             output = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(
-                    py_ast.parse(f.read()), mod_path=py_out_path
+                    py_ast.parse(file_source),
+                    orig_src=ast.JacSource(file_source, py_out_path),
                 ),
             ).ir.unparse()
         self.assertIn("if 0 <= x<= 5 {", output)
@@ -761,9 +778,11 @@ class JacLanguageTests(TestCase):
                 module_path + ".py",
             )
             with open(file_path) as f:
+                file_source = f.read()
                 jac_ast = PyastBuildPass(
                     input_ir=ast.PythonModuleAst(
-                        py_ast.parse(f.read()), mod_path=file_path
+                        py_ast.parse(file_source),
+                        orig_src=ast.JacSource(file_source, file_path),
                     )
                 )
             settings.print_py_raised_ast = True
@@ -786,11 +805,13 @@ class JacLanguageTests(TestCase):
         """Test for access tags working."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
+        sys.stderr = captured_output
         cli.check(
             self.fixture_abs_path("../../tests/fixtures/access_modifier.jac"),
             print_errs=True,
         )
         sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("Invalid access"), 18)
 
@@ -808,10 +829,12 @@ class JacLanguageTests(TestCase):
             parsed_ast = py_ast.parse(f.read())
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast, orig_src=ast.JacSource(f.read(), file_name)
+                    )
                 )
             except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
+                raise Exception(f"Error While Jac to Py AST conversion: {e}")
 
         settings.print_py_raised_ast = True
         ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
@@ -1156,3 +1179,13 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("[MyNode(Name='End'), MyNode(Name='Middle')]\n", stdout_value)
+
+    def test_global_multivar(self) -> None:
+        """Test supporting multiple global variable in a statement."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("glob_multivar_statement", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Hello World !", stdout_value[0])
+        self.assertIn("Welcome to Jaseci!", stdout_value[1])

jaclang/utils/helpers.py

@@ -147,7 +147,7 @@ def dump_traceback(e: Exception) -> str:
         return len(string.encode("utf-8")[:offset].decode("utf-8", errors="replace"))
 
     tb = TracebackException(type(e), e, e.__traceback__, limit=None, compact=True)
-    trace_dump += f"Error: {str(e)}"
+    trace_dump += f"Error: {str(e)}\n"
 
     # The first frame is the call the to the above `exec` function, not usefull to the enduser,
     # and Make the most recent call first.
@@ -155,33 +155,111 @@ def dump_traceback(e: Exception) -> str:
     tb.stack.reverse()
 
     # FIXME: should be some settings, we should replace to ensure the anchors length match.
-    dump_tab_width = 4
+    dump_tab_width = 2
 
     for idx, frame in enumerate(tb.stack):
         func_signature = frame.name + ("()" if frame.name.isidentifier() else "")
 
         # Pretty print the most recent call's location.
-        if idx == 0 and (frame.line and frame.line.strip() != ""):
+        if idx == 0 and (
+            (frame.lineno is not None) and frame.line and frame.line.strip() != ""
+        ):
+
             line_o = frame._original_line.rstrip()  # type: ignore [attr-defined]
-            line_s = frame.line.rstrip() if frame.line else ""
-            stripped_chars = len(line_o) - len(line_s)
-            trace_dump += f'\n{" " * (dump_tab_width * 2)}{line_s}'
             if frame.colno is not None and frame.end_colno is not None:
-                off_start = byte_offset_to_char_offset(line_o, frame.colno)
-                off_end = byte_offset_to_char_offset(line_o, frame.end_colno)
-
-                # A bunch of caret '^' characters under the error location.
-                anchors = (" " * (off_start - stripped_chars - 1)) + "^" * len(
-                    line_o[off_start:off_end].replace("\t", " " * dump_tab_width)
+                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
+
+                # Get the source.
+                file_source = None
+                with open(frame.filename, "r") as file:
+                    file_source = file.read()
+
+                # Get the source offset.
+                lines = file_source.split("\n")
+                for i in range(frame.lineno - 1):
+                    off_start += len(lines[i]) + 1
+                    off_end += len(lines[i]) + 1
+
+                trace_dump += pretty_print_source_location(
+                    frame.filename, file_source, frame.lineno, off_start, off_end
                 )
 
-                trace_dump += f'\n{" " * (dump_tab_width * 2)}{anchors}'
-
         trace_dump += f'\n{" " * dump_tab_width}at {func_signature} {frame.filename}:{frame.lineno}'
 
     return trace_dump
 
 
+# TODO: After implementing the TextRange (or simillar named) class to mark a text range
+# refactor the parameter to accept an instace of that text range object.
+def pretty_print_source_location(
+    file_path: str,
+    file_source: str,
+    error_line: int,
+    pos_start: int,
+    pos_end: int,
+) -> str:
+    """Pretty print internal method for the pretty_print method."""
+    # NOTE: The Line numbers and the column numbers are starts with 1.
+    # We print totally 5 lines (error line and above 2 and bellow 2).
+
+    # The width of the line number we'll be printing (more of a settings).
+    line_num_width: int = 5
+
+    idx: int = pos_start  # Pointer for the current character.
+
+    if file_source == "" or file_path == "":
+        return ""
+
+    start_line: int = error_line - 2
+    if start_line < 1:
+        start_line = 1
+    end_line: int = start_line + 5  # Index is exclusive.
+
+    # Get the first character of the [start_line].
+    file_source.splitlines(True)[start_line - 1]
+    curr_line: int = error_line
+    while idx >= 0 and curr_line >= start_line:
+        idx -= 1
+        if idx < 0:
+            break
+        if file_source[idx] == "\n":
+            curr_line -= 1
+
+    idx += 1  # Enter the line.
+    assert idx == 0 or file_source[idx - 1] == "\n"
+
+    pretty_dump = ""
+
+    # Print each lines.
+    curr_line = start_line
+    while curr_line < end_line:
+        pretty_dump += f"%{line_num_width}d | " % curr_line
+
+        idx_line_start = idx
+        while idx < len(file_source) and file_source[idx] != "\n":
+            idx += 1  # Run to the line end.
+        pretty_dump += file_source[idx_line_start:idx]
+        pretty_dump += "\n"
+
+        if curr_line == error_line:  # Print the current line with indicator.
+            pretty_dump += f"%{line_num_width}s | " % " "
+
+            spaces = ""
+            for idx_pre in range(idx_line_start, pos_start):
+                spaces += "\t" if file_source[idx_pre] == "\t" else " "
+
+            err_token_len = pos_end - pos_start
+            pretty_dump += spaces + ("^" * err_token_len) + "\n"
+
+        if idx == len(file_source):
+            break
+        curr_line += 1
+        idx += 1
+
+    return pretty_dump[:-1]  # Get rid of the last newline (of the last line).
+
+
 class Jdb(pdb.Pdb):
     """Jac debugger."""
 

jaclang/utils/lang_tools.py

@@ -215,12 +215,16 @@ class AstTool:
 
             if file_name.endswith(".py"):
                 with open(file_name, "r") as f:
-                    parsed_ast = py_ast.parse(f.read())
+                    file_source = f.read()
+                    parsed_ast = py_ast.parse(file_source)
                 if output == "pyast":
                     return f"\n{py_ast.dump(parsed_ast, indent=2)}"
                 try:
                     rep = PyastBuildPass(
-                        input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                        input_ir=ast.PythonModuleAst(
+                            parsed_ast,
+                            orig_src=ast.JacSource(file_source, file_name),
+                        ),
                     ).ir
 
                     schedule = py_code_gen_typed

jaclang/utils/treeprinter.py

@@ -105,7 +105,7 @@ def print_ast_tree(
         if isinstance(node, Token) and isinstance(node, AstSymbolNode):
             out = (
                 f"{node.__class__.__name__} - {node.value} - "
-                f"Type: {node.sym_type}, {access} {sym_table_link}"
+                f"Type: {node.expr_type}, {access} {sym_table_link}"
             )
             if settings.ast_symbol_info_detailed:
                 symbol = (
@@ -133,7 +133,7 @@ def print_ast_tree(
         elif isinstance(node, AstSymbolNode):
             out = (
                 f"{node.__class__.__name__} - {node.sym_name} - "
-                f"Type: {node.sym_type}, {access} {sym_table_link}"
+                f"Type: {node.expr_type}, {access} {sym_table_link}"
             )
             if settings.ast_symbol_info_detailed:
                 symbol = (
@@ -143,6 +143,8 @@ def print_ast_tree(
                 )
                 out += f" SymbolPath: {symbol}"
             return out
+        elif isinstance(node, ast.Expr):
+            return f"{node.__class__.__name__} - Type: {node.expr_type}"
         else:
             return f"{node.__class__.__name__}, {access}"
 

{jaclang-0.7.23.dist-info → jaclang-0.7.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.23
+Version: 0.7.25
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT
@@ -14,6 +14,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: llm
 Provides-Extra: streamlit