jaclang 0.7.13__py3-none-any.whl → 0.7.16__py3-none-any.whl

jaclang/runtimelib/machine.py

@@ -0,0 +1,94 @@
+"""Jac Machine module."""
+
+import marshal
+import os
+import types
+from typing import Optional
+
+from jaclang.compiler.absyntree import Module
+from jaclang.compiler.compile import compile_jac
+from jaclang.compiler.constant import Constants as Con
+from jaclang.utils.log import logging
+
+logger = logging.getLogger(__name__)
+
+
+class JacMachine:
+    """JacMachine to handle the VM-related functionalities and loaded programs."""
+
+    def __init__(self, base_path: str = "") -> None:
+        """Initialize the JacMachine object."""
+        # self.loaded_modules: Dict[str, types.ModuleType] = {}
+        if not len(base_path):
+            base_path = os.getcwd()
+        self.base_path = base_path
+        self.base_path_dir = (
+            os.path.dirname(base_path)
+            if not os.path.isdir(base_path)
+            else os.path.abspath(base_path)
+        )
+        self.jac_program: Optional[JacProgram] = None
+
+    def attach_program(self, jac_program: "JacProgram") -> None:
+        """Attach a JacProgram to the machine."""
+        self.jac_program = jac_program
+
+    def get_mod_bundle(self) -> Optional[Module]:
+        """Retrieve the mod_bundle from the attached JacProgram."""
+        if self.jac_program:
+            return self.jac_program.mod_bundle
+        return None
+
+    def get_bytecode(
+        self,
+        module_name: str,
+        full_target: str,
+        caller_dir: str,
+        cachable: bool = True,
+    ) -> Optional[types.CodeType]:
+        """Retrieve bytecode from the attached JacProgram."""
+        if self.jac_program:
+            return self.jac_program.get_bytecode(
+                module_name, full_target, caller_dir, cachable
+            )
+        return None
+
+
+class JacProgram:
+    """Class to hold the mod_bundle and bytecode for Jac modules."""
+
+    def __init__(
+        self, mod_bundle: Optional[Module], bytecode: Optional[dict[str, bytes]]
+    ) -> None:
+        """Initialize the JacProgram object."""
+        self.mod_bundle = mod_bundle
+        self.bytecode = bytecode or {}
+
+    def get_bytecode(
+        self,
+        module_name: str,
+        full_target: str,
+        caller_dir: str,
+        cachable: bool = True,
+    ) -> Optional[types.CodeType]:
+        """Get the bytecode for a specific module."""
+        if self.mod_bundle and isinstance(self.mod_bundle, Module):
+            codeobj = self.mod_bundle.mod_deps[full_target].gen.py_bytecode
+            return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
+        gen_dir = os.path.join(caller_dir, Con.JAC_GEN_DIR)
+        pyc_file_path = os.path.join(gen_dir, module_name + ".jbc")
+        if cachable and os.path.exists(pyc_file_path):
+            with open(pyc_file_path, "rb") as f:
+                return marshal.load(f)
+
+        result = compile_jac(full_target, cache_result=cachable)
+        if result.errors_had or not result.ir.gen.py_bytecode:
+            logger.error(
+                f"While importing {len(result.errors_had)} errors"
+                f" found in {full_target}"
+            )
+            return None
+        if result.ir.gen.py_bytecode is not None:
+            return marshal.loads(result.ir.gen.py_bytecode)
+        else:
+            return None

jaclang/{core → runtimelib}/utils.py

@@ -11,7 +11,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.semtable import SemScope
 
 if TYPE_CHECKING:
-    from jaclang.core.constructs import NodeAnchor, NodeArchitype
+    from jaclang.runtimelib.constructs import NodeAnchor, NodeArchitype
 
 
 @contextmanager
@@ -113,18 +113,26 @@ def get_sem_scope(node: ast.AstNode) -> SemScope:
     a = (
         node.name
         if isinstance(node, ast.Module)
-        else node.name.value if isinstance(node, (ast.Enum, ast.Architype)) else ""
+        else (
+            node.name.value
+            if isinstance(node, (ast.Enum, ast.Architype))
+            else node.name_ref.sym_name if isinstance(node, ast.Ability) else ""
+        )
     )
     if isinstance(node, ast.Module):
         return SemScope(a, "Module", None)
-    elif isinstance(node, (ast.Enum, ast.Architype)):
+    elif isinstance(node, (ast.Enum, ast.Architype, ast.Ability)):
         node_type = (
             node.__class__.__name__
             if isinstance(node, ast.Enum)
-            else node.arch_type.value
+            else ("Ability" if isinstance(node, ast.Ability) else node.arch_type.value)
         )
         if node.parent:
-            return SemScope(a, node_type, get_sem_scope(node.parent))
+            return SemScope(
+                a,
+                node_type,
+                get_sem_scope(node.parent),
+            )
     else:
         if node.parent:
             return get_sem_scope(node.parent)

jaclang/settings.py

@@ -1,4 +1,4 @@
-"""Main settings of Jac lang."""
+"""Main settings of jac lang."""
 
 import configparser
 import os
@@ -19,6 +19,9 @@ class Settings:
     py_raise: bool = False
     py_raise_deep: bool = False
 
+    # Formatter configuration
+    max_line_length: int = 88
+
     # LSP configuration
     lsp_debug: bool = False
 

jaclang/tests/fixtures/abc.jac

@@ -63,15 +63,15 @@ with entry:__main__ {
 glob expected_area = 78.53981633974483;
 
 test calc_area {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    check almostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    check almostEqual(c.area(), expected_area);
 }
 
 test circle_type {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check c.shape_type == ShapeType.CIRCLE;
 }

jaclang/tests/fixtures/blankwithentry.jac

@@ -0,0 +1,3 @@
+with entry:__main__ {}
+
+with entry {print("i work");}

jaclang/tests/fixtures/byllmissue.jac

@@ -5,8 +5,4 @@ class Foo {
     can bar() {
         return 1;
     }
-}
-
-with entry {
-    my_thing = YourThing(level=thingy by llm());
-}
+}

jaclang/tests/fixtures/chandra_bugs2.jac

@@ -1,10 +1,13 @@
 import:py re;
 
-glob a: int=5;
+glob a: int = 5;
 
 with entry {
-    arguments = {x:None  for x in re.findall(r'\{([A-Za-z0-9_]+)\}', "Apple {apple} pineapple {pineapple}")};
-    a: int=5;
+    arguments = {x: None  for x in re.findall(
+        r'\{([A-Za-z0-9_]+)\}',
+        "Apple {apple} pineapple {pineapple}"
+    )};
+    a: int = 5;
     if False {
         with open(f"Apple{apple}.txt") as f { # Fix syntax highlighting
 
@@ -12,15 +15,13 @@ with entry {
         }
     }
     print(arguments);
-    print(
-        """This is a long
-        line of code."""
-    );
+    print("""This is a long
+    line of code.""");
 }
 
-with entry{
-    a={"a":"apple", "b":"ball", "c":"cat"};
-    y={**a, "d":"dog", "e":"elephant"};
+with entry {
+    a = {"a": "apple", "b": "ball", "c": "cat"};
+    y = {**a, "d": "dog", "e": "elephant"};
     print(y);
 }
 # Use before def error would be nice

jaclang/tests/fixtures/cls_method.jac

@@ -0,0 +1,41 @@
+"""Test file for class method."""
+
+class MyClass {
+    can simple_method() -> str {
+        return "Hello, World1!";
+    }
+
+    @classmethod
+    can my_method(cls: Type[MyClass]) -> str {
+        x = cls.__name__;
+        print(x);
+        return "Hello, World2!";
+    }
+}
+
+with entry {
+    a = MyClass.simple_method();
+    b = MyClass.my_method();
+    print(a, b);
+}
+
+class MyClass2 {
+    can Ability_1(self: MyClass2) -> str;
+    @classmethod
+    can Ability_2(cls: Type[MyClass2]) -> str;
+}
+
+:obj:MyClass2:can:Ability_1
+(self: MyClass2) -> str {
+    return "Hello, World!";
+}
+
+:obj:MyClass2:can:Ability_2 {
+    return "Hello, World22!";
+}
+
+with entry {
+    a = MyClass2().Ability_1();
+    b = MyClass2.Ability_2();
+    print(a, b);
+}

jaclang/tests/fixtures/dblhello.jac

@@ -0,0 +1,6 @@
+import hello;
+import hello;
+
+with entry {
+    hello.still_there();
+}

jaclang/tests/fixtures/deep/one_lev.jac

@@ -1,8 +1,8 @@
 import:jac from .deeper, snd_lev as snd_lev;
-import:jac from ..deep, deeper;
-import:jac from ., deeper as mydeeper;
+# import:jac from ..deep, deeper;
+# import:jac from ., deeper as mydeeper;
 
 can olprint -> str {
     # deeper.snd_lev.slprint(); FIXME:
     return "one level deeper" + snd_lev.slprint();
-}
+}

jaclang/tests/fixtures/deep/one_lev_dup.jac

@@ -1,6 +1,5 @@
-import:jac deeper.snd_lev as snd_lev;
+import:jac from .deeper, snd_lev as snd_lev;
 
-can olprint ->str {
+can olprint -> str {
     return "one level deeper" + snd_lev.slprint();
 }
-

jaclang/tests/fixtures/deep_import_mods.jac

@@ -0,0 +1,13 @@
+import:py sys;
+
+with entry {
+    before_mod = list(sys.modules.keys());
+}
+
+import:jac deep.one_lev as one_lev;
+import:jac from deep.one_lev, olprint;
+
+with entry {
+    after_mod = [m for m in sys.modules.keys() if m not in before_mod];
+    print(after_mod);
+}

jaclang/tests/fixtures/err.impl.jac

@@ -0,0 +1,3 @@
+:o:HasFault:c:init {
+    print(5 / 0);
+}

jaclang/tests/fixtures/err.jac

@@ -1,5 +1,7 @@
-"""Demo"""
+obj HasFault {
+    can init;
+}
 
 can speak {
-    "Hello" |> aprint;
+    HasFault();
 }

jaclang/tests/fixtures/err.test.jac

@@ -0,0 +1,3 @@
+test baddy {
+    print(5 / 0);
+}

jaclang/tests/fixtures/err_runtime.jac

@@ -0,0 +1,15 @@
+
+can bar(some_list:list) {
+    invalid_index = 4;
+    print(some_list[invalid_index]);  # This should fail.
+}
+
+
+can foo() {
+    bar([0, 1, 2, 3]);
+}
+
+
+with entry {
+    foo();
+}

jaclang/tests/fixtures/game1.jac

@@ -1,5 +1,5 @@
 import:py random;
-import:py from typing, Tuple;
+import:py from typing { Tuple }
 
 obj Button {
     can is_pressed(pos: tuple, pressed: str) -> bool {

jaclang/tests/fixtures/hello.jac

@@ -1,5 +1,9 @@
 """Hello World!"""
 
+can still_there {
+    print("im still here");
+}
+
 with entry {
     "Hello World!" |> print;
 }

jaclang/tests/fixtures/impl_grab.impl.jac

@@ -1,4 +1,5 @@
 import:py math;
+
 :can:test_grab {
     return math.sqrt(2);
-}
+}

jaclang/tests/fixtures/impl_grab.jac

@@ -1,2 +1,5 @@
 can test_grab;
-with entry {print(test_grab());}
+
+with entry {
+    print(test_grab());
+}

jaclang/tests/fixtures/jp_importer_auto.jac

@@ -0,0 +1,14 @@
+import from math { sin as s, cos, sqrt as sq }
+include random;
+import from ..test_cli, JacCliTests as Jac;
+import from deep.mycode, code as c;
+import hashcheck as h, assign_compr as a;
+import from jacsamp, my_print as m;
+
+with entry {
+    print(sq(4), s(30), cos(30));
+    print(randint(1, 10));
+    print(m("--->my_print<---"));
+    print(h.a, a.mvar);
+    print(c());
+}

jaclang/tests/fixtures/maxfail_run_test.jac

@@ -1,17 +1,17 @@
 glob x = 5, y = 2;
 
 test a {
-    check assertAlmostEqual(5, x);
+    check almostEqual(5, x);
 }
 
 test b {
-    check assertIn("l", "llm");
+    check "l" in "llm";
 }
 
 test c {
-    check assertEqual(x - y, 3);
+    check x - y == 3;
 }
 
 test d {
-    check assertEqual(1, 2);
+    check 1 == 2;
 }

jaclang/tests/fixtures/needs_import.jac

@@ -3,7 +3,7 @@
 import:py os;
 import:py pyfunc;
 import:py random;
-import:py from pyfunc, my_print;
+import:py from pyfunc { my_print }
 
 with entry {
     my_print(pyfunc);
@@ -11,7 +11,7 @@ with entry {
 }
 
 import:py circle_pysolo;
-import:py from circle_pysolo, calculate_area;
+import:py from circle_pysolo { calculate_area }
 
 with entry {
     print(f"are {calculate_area(2.0)}");

jaclang/tests/fixtures/pyfunc_2.py

@@ -277,3 +277,6 @@ def foo() -> None:
 
 
 foo()
+
+node = 90
+print(node)

jaclang/tests/fixtures/registry.jac

@@ -24,6 +24,15 @@ glob personality_examples: 'Personality Information of Famous People': dict[str,
 
 glob person_value : list[tuple[dict[str, Personality], int]] =(-90);
 
+can 'GenAI ability'
+genai_ability(x: 'Something': str) -> 'Something Else': str by llm();
+
+can 'Normal ability'
+normal_ability(x: 'Something': str) -> 'Something Else': str {
+    y = 10;
+    return x;
+}
+
 can foo() {
    person_value=22;
    can bar() {

jaclang/tests/fixtures/run_test.jac

@@ -1,17 +1,17 @@
 glob a = 5, b = 2;
 
 test t1 {
-    check assertAlmostEqual(a, 6);
+    check almostEqual(a, 6);
 }
 
 test t2 {
-    check assertTrue(a != b);
+    check a != b;
 }
 
 test t3 {
-    check assertIn("d", "abc");
+    check "d" in "abc";
 }
 
 test t4 {
-    check assertEqual(a - b, 3);
+    check a - b == 3;
 }

jaclang/tests/fixtures/semstr.jac

@@ -27,7 +27,4 @@ journal {
 can add() -> 'no of': int {}
 
 can 'update user mood'
-updateMood(* mood: 'Moo of the Person': str,  something:'Something':str, something_else: 'Something Else': int = 5, without_semstr: float) -> 'mood selection': str {}
-
-
- can get_personality (person: 'Person Object': list[Person]) -> 'Personality of the Person': dict[Personality, PersonalityIndex] by llm(reason=True, incl_info=(personality_examples, self.diary_entries));
+updateMood(* mood: 'Moo of the Person': str,  something:'Something':str, something_else: 'Something Else': int = 5, without_semstr: float) -> 'mood selection': str {}

jaclang/tests/fixtures/simple_archs.jac

@@ -15,7 +15,7 @@ class SimpleClass {
         var2: int,
         var3: int = 0;
 
-    can init {
+    can init(self: SimpleClass) {
         print(self.var3);
     }
 }

jaclang/tests/test_cli.py

@@ -5,6 +5,7 @@ import io
 import os
 import subprocess
 import sys
+import traceback
 
 from jaclang.cli import cli
 from jaclang.plugin.builtin import dotgen
@@ -38,7 +39,7 @@ class JacCliTests(TestCase):
         sys.stderr = captured_output
 
         try:
-            cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])  # type: ignore
+            cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])
         except Exception as e:
             print(f"Error: {e}")
 
@@ -46,7 +47,69 @@ class JacCliTests(TestCase):
         sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         # print(stdout_value)
-        self.assertIn("Syntax Error", stdout_value)
+        self.assertIn("Error", stdout_value)
+
+    def test_jac_cli_alert_based_runtime_err(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        try:
+            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__
+
+        expected_stdout_values = (
+            "Error: list index out of range",
+            "    print(some_list[invalid_index]);",
+            "          ^^^^^^^^^^^^^^^^^^^^^^^^",
+            "  at bar() ",
+            "  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)
+
+    def test_jac_impl_err(self) -> None:
+        """Basic test for pass."""
+        if "jaclang.tests.fixtures.err" in sys.modules:
+            del sys.modules["jaclang.tests.fixtures.err"]
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        try:
+            cli.enter(self.fixture_abs_path("err.jac"), entrypoint="speak", args=[])
+        except Exception:
+            traceback.print_exc()
+
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        # print(stdout_value)
+        path_to_file = self.fixture_abs_path("err.impl.jac")
+        self.assertIn(f'"{path_to_file}", line 2', stdout_value)
+
+    def test_jac_test_err(self) -> None:
+        """Basic test for pass."""
+        if "jaclang.tests.fixtures.err" in sys.modules:
+            del sys.modules["jaclang.tests.fixtures.err"]
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+        cli.test(self.fixture_abs_path("err.jac"))
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        # print(stdout_value)
+        path_to_file = self.fixture_abs_path("err.test.jac")
+        self.assertIn(f'"{path_to_file}", line 2,', stdout_value)
 
     def test_jac_ast_tool_pass_template(self) -> None:
         """Basic test for pass."""