jaclang 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

jaclang/runtimelib/utils.py

@@ -14,6 +14,35 @@ if TYPE_CHECKING:
     from jaclang.runtimelib.constructs import NodeAnchor, NodeArchetype
 
 
+def read_file_with_encoding(file_path: str) -> str:
+    """Read file with proper encoding detection."""
+    encodings_to_try = [
+        "utf-8-sig",
+        "utf-8",
+        "utf-16",
+        "utf-16le",
+        "utf-16be",
+        # "latin-1", # TODO: Support reading files with Latin-1 encoding
+    ]
+
+    for encoding in encodings_to_try:
+        try:
+            with open(file_path, "r", encoding=encoding) as f:
+                return f.read()
+        except UnicodeError:
+            continue
+        except Exception as e:
+            raise IOError(
+                f"Could not read file {file_path}: {e}. "
+                f"Report this issue: https://github.com/jaseci-labs/jaseci/issues"
+            ) from e
+
+    raise IOError(
+        f"Could not read file {file_path} with any encoding. "
+        f"Report this issue: https://github.com/jaseci-labs/jaseci/issues"
+    )
+
+
 @contextmanager
 def sys_path_context(path: str) -> Iterator[None]:
     """Add a path to sys.path temporarily."""

jaclang/tests/fixtures/pyfunc_fmt.py

@@ -0,0 +1,60 @@
+
+
+
+
+if __name__ == "__main__":
+
+    def foo():
+        print("One")
+        return "foo"
+    foo()
+
+condition = True
+
+if condition:
+
+    print("Two")
+    
+    def bar():
+        return 
+    
+    main_mod = None
+    bar()
+
+def baz():
+    print("Three")
+    return "baz"
+
+print(baz())    
+
+
+try:
+    a = 90
+except FileNotFoundError:
+    pass
+
+
+condition = 10
+
+
+while condition:
+    print("Processing...")
+
+    while condition:
+        print("Four")
+        condition -= 10
+        break 
+
+if condition:
+
+    def foo():
+        return 
+    foo()
+    print("Exiting the loop.")
+
+if condition:
+    print("still +")
+    def foo():
+        return 
+
+print("The End.")

jaclang/tests/fixtures/pyfunc_fstr.py

@@ -0,0 +1,25 @@
+
+
+
+
+
+name = 'Peter'
+relation = 'mother'
+mom_name = 'Mary'
+
+
+print(f"Hello {name}")
+print(f"Hello {name} {name}")
+print(f"{name} squared is {name} {name}")
+
+
+print(f"{name.upper()}!  wrong poem.")
+print(f"Hello {name} , yoo {relation} is {mom_name}. Myself, I am {name}.")
+
+
+
+item = "Apple"
+price = 1.23
+
+print(f"Left aligned: {item:<10} | Price: {price:.2f}")
+print(f"{name = } 🤔") 

jaclang/tests/fixtures/pyfunc_kwesc.py

@@ -0,0 +1,33 @@
+
+
+
+def foo(type= 90):
+    """This is a function with a docstring."""
+    return type
+
+print(foo(type=89))
+
+def bar(node= 12, *args,**kwargs):
+    """This is another function with a docstring."""
+    return node, args, kwargs
+
+print(str(bar(node=13, a=1, b=2)))
+
+
+functions = [
+
+        dict(   
+            name="replace_lines",
+            args=[
+                dict(name="text", type="str", default=None),
+                dict(name="old", type="str", default=None),
+                dict(name="new", type="str", default=None),
+            ],
+            returns=dict(type="str", default=None),
+        ),
+]
+
+print(f"Functions: {functions}")
+
+dict = 90
+print(f"Dict: {dict}")

jaclang/tests/fixtures/python_run_test.py

@@ -0,0 +1,19 @@
+"""Simple Python test file for jac run command."""
+
+print("Hello from Python!")
+print("This is a test Python file.")
+
+def main():
+    """Main function to demonstrate execution."""
+    result = 42
+    print(f"Result: {result}")
+    return result
+
+if __name__ == "__main__":
+    main()
+    print("Python execution completed.")
+
+
+from jaclang.tests.fixtures import py_namedexpr
+
+py_namedexpr.walrus_example()

jaclang/tests/test_cli.py

@@ -35,6 +35,73 @@ class JacCliTests(TestCase):
 
         self.assertIn("Hello World!", stdout_value)
 
+    def test_jac_cli_run_python_file(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("python_run_test.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("Hello from Python!", stdout_value)
+        self.assertIn("This is a test Python file.", stdout_value)
+        self.assertIn("Result: 42", stdout_value)
+        self.assertIn("Python execution completed.", stdout_value)
+        self.assertIn("10", stdout_value)
+
+    def test_jac_run_py_fstr(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("pyfunc_fstr.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("Hello Peter", stdout_value)
+        self.assertIn("Hello Peter Peter", stdout_value)
+        self.assertIn("Peter squared is Peter Peter", stdout_value)
+        self.assertIn("PETER!  wrong poem", stdout_value)
+        self.assertIn("Hello Peter , yoo mother is Mary. Myself, I am Peter.", stdout_value)
+        self.assertIn("Left aligned: Apple | Price: 1.23", stdout_value)
+        self.assertIn("name = Peter 🤔", stdout_value)
+
+    def test_jac_run_py_fmt(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("pyfunc_fmt.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertIn("One", stdout_value)
+        self.assertIn("Two", stdout_value)
+        self.assertIn("Three", stdout_value)
+        self.assertIn("baz", stdout_value)
+        self.assertIn("Processing...", stdout_value)
+        self.assertIn("Four", stdout_value)
+        self.assertIn("The End.", stdout_value)
+
+    def test_jac_run_pyfunc_kwesc(self) -> None:
+        """Test running Python files with jac run command."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.run(self.fixture_abs_path("pyfunc_kwesc.py"))
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        out = stdout_value.split("\n")
+        self.assertIn("89", out[0])
+        self.assertIn("(13, (), {'a': 1, 'b': 2})", out[1])
+        self.assertIn("Functions: [{'name': 'replace_lines'", out[2])
+        self.assertIn("Dict: 90", out[3])
+
     def test_jac_cli_alert_based_err(self) -> None:
         """Basic test for pass."""
         captured_output = io.StringIO()

jaclang/tests/test_language.py

@@ -13,6 +13,7 @@ from jaclang import JacMachine as Jac
 from jaclang.cli import cli
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
+from jaclang.runtimelib.utils import read_file_with_encoding
 
 
 class JacLanguageTests(TestCase):
@@ -1363,4 +1364,98 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Num:  4", stdout_value[0])
         self.assertIn("Num:  3", stdout_value[1])
-        self.assertIn("Completed", stdout_value[2])
+        self.assertIn("Completed", stdout_value[2])
+
+    def test_read_file_with_encoding_utf8(self) -> None:
+        """Test reading UTF-8 encoded file."""
+        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
+            test_content = "Hello, 世界! 🌍 Testing UTF-8 encoding."
+            f.write(test_content)
+            temp_path = f.name
+        
+        try:
+            result = read_file_with_encoding(temp_path)
+            self.assertEqual(result, test_content)
+        finally:
+            os.unlink(temp_path)
+
+    def test_read_file_with_encoding_utf16(self) -> None:
+        """Test reading UTF-16 encoded file when UTF-8 fails."""
+        with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-16") as f:
+            test_content = "Hello, 世界! UTF-16 encoding test."
+            f.write(test_content)
+            temp_path = f.name
+        
+        try:
+            result = read_file_with_encoding(temp_path)
+            self.assertEqual(result, test_content)
+        finally:
+            os.unlink(temp_path)
+
+    def test_read_file_with_encoding_utf8_bom(self) -> None:
+        """Test reading UTF-8 with BOM encoded file."""
+        with tempfile.NamedTemporaryFile(delete=False, mode='w', encoding='utf-8-sig') as f:
+            test_content = "Hello, UTF-8 BOM test! 🚀"
+            f.write(test_content)
+            temp_path = f.name
+        
+        try:
+            result = read_file_with_encoding(temp_path)
+            self.assertEqual(result, test_content)
+        finally:
+            os.unlink(temp_path)
+
+    # TODO: Support reading files with Latin-1 encoding
+    # def test_read_file_with_encoding_latin1(self) -> None:
+    #     """Test reading Latin-1 encoded file as fallback."""
+    #     with tempfile.NamedTemporaryFile(mode='w', encoding='latin-1', delete=False) as f:
+    #         test_content = "Hello, café! Latin-1 test."
+    #         f.write(test_content)
+    #         f.flush()
+    #         temp_path = f.name
+
+    #     try:
+    #         result = read_file_with_encoding(temp_path)
+    #         self.assertEqual(result, test_content)
+    #     finally:
+    #         os.unlink(temp_path)
+
+    def test_read_file_with_encoding_binary_file_fallback(self) -> None:
+        """Test reading binary file falls back to latin-1."""
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            binary_data = bytes([0xFF, 0xFE, 0x00, 0x48, 0x65, 0x6C, 0x6C, 0x6F])
+            f.write(binary_data)
+            f.flush()  
+            temp_path = f.name
+        
+        try:
+            result = read_file_with_encoding(temp_path)
+            self.assertIsInstance(result, str)
+            self.assertGreater(len(result), 0)
+        finally:
+            os.unlink(temp_path)
+
+    def test_read_file_with_encoding_special_characters(self) -> None:
+        """Test reading file with various special characters."""
+        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
+            test_content = (
+                "Special chars: åäö ñ ü ç é\n"
+                "Symbols: ©®™ §¶†‡•\n" 
+                "Math: ∑∏∫√±≤≥≠\n"
+                "Arrows: ←→↑↓↔\n"
+                "Emoji: 😀😍🎉🔥💯\n"
+            )
+            f.write(test_content)
+            f.flush()  
+            temp_path = f.name
+        
+        try:
+            result = read_file_with_encoding(temp_path)
+
+            self.assertEqual(result, test_content)
+            self.assertIn("åäö", result)
+            self.assertIn("©®™", result)
+            self.assertIn("∑∏∫", result)
+            self.assertIn("😀😍", result)
+        finally:
+            os.unlink(temp_path)

jaclang/utils/lang_tools.py

@@ -11,6 +11,7 @@ from jaclang.compiler.passes.main import PyastBuildPass
 from jaclang.compiler.passes.tool.doc_ir_gen_pass import DocIRGenPass
 from jaclang.compiler.program import JacProgram
 from jaclang.compiler.unitree import UniScopeNode
+from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.utils.helpers import auto_generate_refs, pascal_to_snake
 
 
@@ -194,9 +195,8 @@ class AstTool:
             base = base if base else "./"
 
             if file_name.endswith(".py"):
-                with open(file_name, "r") as f:
-                    file_source = f.read()
-                    parsed_ast = py_ast.parse(file_source)
+                file_source = read_file_with_encoding(file_name)
+                parsed_ast = py_ast.parse(file_source)
                 if output == "pyast":
                     return f"\n{py_ast.dump(parsed_ast, indent=2)}"
                 try:

jaclang/utils/module_resolver.py

@@ -57,6 +57,18 @@ def resolve_module(target: str, base_path: str) -> Tuple[str, str]:
         if res:
             return res
 
+    typeshed_paths = get_typeshed_paths()
+    for typeshed_dir in typeshed_paths:
+        res = _candidate_from_typeshed(typeshed_dir, actual_parts)
+        if res:
+            # print(f"Found '{target}' in typeshed: {res[0]}")
+            return res
+
+    # If not found in any typeshed directory, but typeshed is configured,
+    # return a stub .pyi path for type checking.
+    stub_pyi_path = os.path.join(typeshed_paths[0], *actual_parts) + ".pyi"
+    if os.path.isfile(stub_pyi_path):
+        return stub_pyi_path, "pyi"
     base_dir = base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
     for _ in range(max(level - 1, 0)):
         base_dir = os.path.dirname(base_dir)
@@ -90,3 +102,81 @@ def resolve_relative_path(target: str, base_path: str) -> str:
     """Resolve only the path component for a target."""
     path, _ = resolve_module(target, base_path)
     return path
+
+
+def get_typeshed_paths() -> list[str]:
+    """Return the typeshed stubs and stdlib directories if available."""
+    # You may want to make this configurable or autodetect
+    # Corrected base path calculation: removed one ".."
+    base = os.path.join(
+        os.path.dirname(__file__),  # jaclang/utils
+        "..",  # jaclang
+        "vendor",
+        "typeshed",  # jaclang/vendor/typeshed
+    )
+    base = os.path.abspath(base)
+    stubs = os.path.join(base, "stubs")
+    stdlib = os.path.join(base, "stdlib")
+    paths = []
+    if os.path.isdir(stubs):
+        paths.append(stubs)
+    if os.path.isdir(stdlib):
+        paths.append(stdlib)
+    return paths
+
+
+def _candidate_from_typeshed(base: str, parts: list[str]) -> Optional[Tuple[str, str]]:
+    """Find .pyi files in typeshed, trying module.pyi then package/__init__.pyi."""
+    if not parts:  #
+        return None
+
+    # This is the path prefix for the module/package, e.g., os.path.join(base, "collections", "abc")
+    candidate_prefix = os.path.join(base, *parts)
+
+    # 1. Check for a direct module file (e.g., base/parts.pyi or base/package/module.pyi)
+    # Example: parts=["collections", "abc"] -> candidate_prefix = base/collections/abc
+    # module_file_pyi = base/collections/abc.pyi
+    # Example: parts=["sys"] -> candidate_prefix = base/sys
+    # module_file_pyi = base/sys.pyi
+    module_file_pyi = candidate_prefix + ".pyi"
+    if os.path.isfile(module_file_pyi):
+        return module_file_pyi, "pyi"
+
+    # 2. Check if the candidate_prefix itself is a directory (package)
+    #    and look for __init__.pyi inside it.
+    # Example: parts=["_typeshed"] -> candidate_prefix = base/_typeshed
+    # init_pyi = base/_typeshed/__init__.pyi
+    if os.path.isdir(candidate_prefix):
+        init_pyi = os.path.join(candidate_prefix, "__init__.pyi")
+        if os.path.isfile(init_pyi):
+            return init_pyi, "pyi"
+
+        # Heuristic for packages where stubs are in a subdirectory of the same name
+        # e.g., parts = ["requests"], candidate_prefix = base/requests
+        # checks base/requests/requests/__init__.pyi
+        # This part of the original heuristic is preserved.
+        if parts:  # Ensure parts is not empty for parts[-1]
+            inner_pkg_init_pyi = os.path.join(
+                candidate_prefix, parts[-1], "__init__.pyi"
+            )
+            if os.path.isfile(inner_pkg_init_pyi):
+                return inner_pkg_init_pyi, "pyi"
+
+    return None
+
+
+class PythonModuleResolver:
+    """Resolver for Python modules with enhanced import capabilities."""
+
+    def resolve_module_path(self, target: str, base_path: str) -> str:
+        """Resolve Python module path without importing."""
+        caller_dir = (
+            base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
+        )
+        caller_dir = caller_dir if caller_dir else os.getcwd()
+        local_py_file = os.path.join(caller_dir, target.split(".")[-1] + ".py")
+
+        if os.path.exists(local_py_file):
+            return local_py_file
+        else:
+            raise ImportError(f"Module '{target}' not found in {caller_dir}")

jaclang/utils/symtable_test_helpers.py

@@ -0,0 +1,125 @@
+"""Symbol table testing helpers for Jaseci."""
+
+from typing import Optional
+
+from jaclang.compiler.unitree import Symbol, UniScopeNode
+from jaclang.utils.test import TestCase
+
+
+class SymTableTestMixin(TestCase):
+    """Mixin class providing assertion methods for symbol table testing."""
+
+    def assert_symbol_exists(
+        self,
+        sym_table: UniScopeNode,
+        symbol_name: str,
+        symbol_type: Optional[str] = None,
+    ) -> Symbol:
+        """Assert that a symbol exists in the symbol table."""
+        symbol = look_down(sym_table, symbol_name)
+        self.assertIsNotNone(
+            symbol, f"Symbol '{symbol_name}' not found in symbol table"
+        )
+        if symbol_type:
+            self.assertIn(
+                symbol_type,
+                str(symbol),
+                f"Symbol '{symbol_name}' is not of type '{symbol_type}'",
+            )
+        return symbol
+
+    def assert_symbol_decl_at(self, symbol: Symbol, line: int, col: int) -> None:
+        """Assert that a symbol is declared at specific line and column."""
+        decl_info = str(symbol)
+        expected_decl = f"{line}:{col}"
+        self.assertIn(
+            expected_decl,
+            decl_info,
+            f"Symbol declaration not found at {expected_decl}. Got: {decl_info}",
+        )
+
+    def assert_symbol_defns_at(
+        self, symbol: Symbol, expected_defns: list[tuple[int, int]]
+    ) -> None:
+        """Assert that a symbol has definitions at specific locations."""
+        symbol_str = str(symbol)
+        for line, col in expected_defns:
+            expected_defn = f"{line}:{col}"
+            self.assertIn(
+                expected_defn,
+                symbol_str,
+                f"Symbol definition not found at {expected_defn}. Got: {symbol_str}",
+            )
+
+    def assert_symbol_uses_at(
+        self, symbol: Symbol, expected_uses: list[tuple[int, int]]
+    ) -> None:
+        """Assert that a symbol has uses at specific locations."""
+        symbol_uses_str = str(symbol.uses)
+        for line, col in expected_uses:
+            expected_use = f"{line}:{col}"
+            self.assertIn(
+                expected_use,
+                symbol_uses_str,
+                f"Symbol use not found at {expected_use}. Got: {symbol_uses_str}",
+            )
+
+    def assert_symbol_complete(
+        self,
+        sym_table: UniScopeNode,
+        symbol_name: str,
+        symbol_type: str,
+        decl: tuple[int, int],
+        defns: Optional[list[tuple[int, int]]] = None,
+        uses: Optional[list[tuple[int, int]]] = None,
+    ) -> None:
+        """Assert complete symbol information (declaration, definitions, uses)."""
+        symbol = self.assert_symbol_exists(sym_table, symbol_name, symbol_type)
+        self.assert_symbol_decl_at(symbol, decl[0], decl[1])
+
+        if defns:
+            self.assert_symbol_defns_at(symbol, defns)
+
+        if uses:
+            self.assert_symbol_uses_at(symbol, uses)
+
+    def assert_sub_table_exists(
+        self, sym_table: UniScopeNode, table_name: str, tab_type: str
+    ) -> None:
+        """Assert that a sub-table exists in the symbol table."""
+        sub_tables = sym_table.kid_scope
+        table_names = [table.scope_name for table in sub_tables]
+        type_names = [table.get_type() for table in sub_tables]
+        matching_tables = [name for name in table_names if table_name in name]
+        matching_types = [
+            type_name for type_name in type_names if tab_type in str(type_name)
+        ]
+        self.assertTrue(
+            len(matching_tables) > 0,
+            f"Sub-table '{table_name}' not found. Available: {table_names}",
+        )
+        self.assertTrue(
+            len(matching_types) > 0,
+            f"Sub-table type '{tab_type}' not found in {table_names} of types {type_names}",
+        )
+        return sub_tables[table_names.index(matching_tables[0])]
+
+
+def look_down(tab: UniScopeNode, name: str, deep: bool = True) -> Optional[Symbol]:
+    """Lookup a variable in the symbol table."""
+    if name in tab.names_in_scope:
+        if not tab.names_in_scope[name].imported:
+            return tab.names_in_scope[name]
+        else:
+            sym = tab.names_in_scope[name]
+            return sym
+    for i in tab.inherited_scope:
+        found = i.lookup(name, deep=False)
+        if found:
+            return found
+    if deep and tab.kid_scope:
+        for kid in tab.kid_scope:
+            found = kid.lookup(name, deep=True)
+            if found:
+                return found
+    return None

jaclang/utils/test.py

@@ -9,6 +9,7 @@ from _pytest.logging import LogCaptureFixture
 
 import jaclang
 from jaclang.compiler.passes import UniPass
+from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.utils.helpers import get_uni_nodes_as_snake_case as ast_snakes
 
 import pytest
@@ -41,13 +42,11 @@ class TestCase(_TestCase):
             raise ValueError("Unable to determine the file of the module.")
         fixture_src = module.__file__
         fixture_path = os.path.join(os.path.dirname(fixture_src), "fixtures", fixture)
-        with open(fixture_path, "r", encoding="utf-8") as f:
-            return f.read()
+        return read_file_with_encoding(fixture_path)
 
     def file_to_str(self, file_path: str) -> str:
         """Load fixture from fixtures directory."""
-        with open(file_path, "r", encoding="utf-8") as f:
-            return f.read()
+        return read_file_with_encoding(file_path)
 
     def fixture_abs_path(self, fixture: str) -> str:
         """Get absolute path of a fixture from fixtures directory."""

jaclang/vendor/interegular/__init__.py

@@ -0,0 +1,34 @@
+"""
+A package to compare python-style regexes and test if they have intersections.
+Based on the `greenery`-package by @qntm, adapted and specialized for `lark-parser`
+"""
+
+from typing import Iterable, Tuple
+
+from interegular.fsm import FSM
+from interegular.patterns import Pattern, parse_pattern, REFlags, Unsupported, InvalidSyntax
+from interegular.comparator import Comparator
+from interegular.utils import logger
+
+__all__ = ['FSM', 'Pattern', 'Comparator', 'parse_pattern', 'compare_patterns', 'compare_regexes', '__version__', 'REFlags', 'Unsupported',
+           'InvalidSyntax']
+
+
+def compare_regexes(*regexes: str) -> Iterable[Tuple[str, str]]:
+    """
+    Checks the regexes for intersections. Returns all pairs it found
+    """
+    c = Comparator({r: parse_pattern(r) for r in regexes})
+    print(c._patterns)
+    return c.check(regexes)
+
+
+def compare_patterns(*ps: Pattern) -> Iterable[Tuple[Pattern, Pattern]]:
+    """
+    Checks the Patterns for intersections. Returns all pairs it found
+    """
+    c = Comparator({p: p for p in ps})
+    return c.check(ps)
+
+
+__version__ = "0.3.3"