jaclang 0.7.1__py3-none-any.whl → 0.7.7__py3-none-any.whl

jaclang/plugin/tests/test_features.py

@@ -1,12 +1,8 @@
 """Tests for Jac parser."""
 
 import inspect
-import io
-import sys
-import traceback
 from typing import List, Type
 
-from jaclang.cli import cli
 from jaclang.plugin.default import JacFeatureDefaults
 from jaclang.plugin.feature import JacFeature
 from jaclang.plugin.spec import JacFeatureSpec
@@ -58,32 +54,3 @@ class TestFeatures(TestCase):
         self.assertEqual(jac_feature_spec_methods, jac_feature_defaults_methods)
         for i in jac_feature_spec_methods:
             self.assertIn(i, jac_feature_methods)
-
-    def test_impl_match_error_reporting(self) -> None:
-        """Basic test for error reporting."""
-        captured_output = io.StringIO()
-        original_stderr = sys.stderr
-        sys.stderr = captured_output
-
-        try:
-            # Execute the function that is expected to raise an exception
-            cli.run(self.fixture_abs_path("impl_match.jac"))  # type: ignore
-        except Exception:
-            # Print the full stack trace to the captured output
-            traceback.print_exc(file=captured_output)
-        finally:
-            # Restore the original stderr
-            sys.stderr = original_stderr
-
-        # Retrieve the captured output
-        stderr_val = captured_output.getvalue()
-        # Assertions or verifications
-        try:
-            self.assertIn("impl_match.jac", stderr_val)
-            self.assertIn("impl_match_impl.jac", stderr_val)
-            self.assertLess(
-                stderr_val.index("impl_match.jac"),
-                stderr_val.index("impl_match_impl.jac"),
-            )
-        except AssertionError:
-            self.skipTest("Error reporting not implemented yet")

jaclang/settings.py

@@ -12,11 +12,15 @@ class Settings:
     # Debug configuration
     fuse_type_info_debug: bool = False
     filter_sym_builtins: bool = True
+    ast_symbol_info_detailed: bool = False
 
     # Import configuration
     py_raise: bool = False
     py_raise_deep: bool = False
 
+    # LSP configuration
+    lsp_debug: bool = False
+
     def __post_init__(self) -> None:
         """Initialize settings."""
         home_dir = os.path.expanduser("~")

jaclang/tests/fixtures/abc.jac

@@ -18,9 +18,9 @@ Below we have the demonstration of a class to calculate the area of a circle.
 *#
 
 """Enum for shape types"""
-enum ShapeType  {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+enum ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Base class for a shape."""
@@ -50,24 +50,28 @@ with entry {
 # Global also works here
 
 with entry:__main__ {
-# To run the program functionality
-print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    # To run the program functionality
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }
 # Unit Tests!
 
 glob expected_area = 78.53981633974483;
 
-test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+test calc_area {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
-test circle_area   {
+test circle_area {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
-test circle_type   {
+test circle_type {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/tests/fixtures/aott_raise.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms.base, BaseLLM;
 
 obj model:BaseLLM: {
     can __infer__(meaning_in: str, **kwargs: dict) {

jaclang/tests/fixtures/byllmissue.jac

@@ -0,0 +1,12 @@
+class Foo {
+    '''
+    a doc string
+    '''
+    can bar() {
+        return 1;
+    }
+}
+
+with entry {
+    my_thing = YourThing(level=thingy by llm());
+}

jaclang/tests/fixtures/edgetypeissue.jac

@@ -0,0 +1,10 @@
+node x {}
+
+edge e {
+    has name: str;
+}
+
+with entry {
+    nodes = root +:e(name="hello"):+> x();
+    print(nodes);
+}

jaclang/tests/fixtures/hash_init_check.jac

@@ -0,0 +1,17 @@
+obj TYPE {
+    can init() {
+        DICT:dict = {};
+        DICT[self] = 1;
+    }
+}
+
+obj TASK:TYPE: {
+    can init() {
+        TYPE.init(self);
+    }
+}
+
+with entry {
+    TASK();
+    print('Test Passed');
+}

jaclang/tests/fixtures/hello.jac

@@ -2,4 +2,4 @@
 
 with entry {
     "Hello World!" |> print;
-}
+}

jaclang/tests/fixtures/impl_match_confused.impl.jac

@@ -0,0 +1 @@
+:walker:gen_outline:can:get_highlights {}

jaclang/tests/fixtures/impl_match_confused.jac

@@ -0,0 +1,5 @@
+walker get_highlights {}
+
+walker gen_outline {
+    can get_highlights_and_documents with project entry;
+}

jaclang/tests/fixtures/maxfail_run_test.jac

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

jaclang/tests/fixtures/nosigself.jac

@@ -0,0 +1,19 @@
+obj Foo {
+    has a: int = 5;
+
+    can say {
+        print(self.a);
+    }
+
+    can say2;
+}
+
+:o:Foo:c:say2 {
+    print(self.a);
+}
+
+with entry {
+    f = Foo();
+    f.say();
+    f.say2();
+}

jaclang/tests/fixtures/run_test.jac

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

jaclang/tests/fixtures/walker_override.jac

@@ -0,0 +1,21 @@
+walker a {
+    can foo with `root entry {
+        print("foo");
+    }
+}
+
+walker b :a: {
+    can bar with `root entry {
+        print("bar");
+    }
+}
+
+walker c :b: {
+    override can foo with `root entry {
+        print("baz");
+    }
+}
+
+with entry {
+    root spawn c();
+}

jaclang/tests/fixtures/with_llm_function.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init {

jaclang/tests/fixtures/with_llm_lower.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init {

jaclang/tests/fixtures/with_llm_method.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init {

jaclang/tests/fixtures/with_llm_type.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init(output_str: str) {

jaclang/tests/fixtures/with_llm_vision.jac

@@ -0,0 +1,25 @@
+import:py from mtllm.llms, BaseLLM;
+import:py from PIL, Image;
+import:py os;
+
+obj model:BaseLLM: {
+    can init {
+        self.verbose = False;
+        self.max_tries = 1;
+    }
+    can __infer__(meaning_in: str, **kwargs: dict) {
+        print(kwargs);
+        print(meaning_in);
+        return "[Output] Something";
+    }
+}
+glob llm = model();
+
+can 'Solve the Given Math Question'
+solve_math_question(question_img: 'Image of the Question': Image) -> 'Answer to the Question': str
+by llm(method="Chain-of-Thoughts");
+
+with entry {
+    question_img = Image.open(os.path.join(os.path.dirname(__file__), 'math_question.jpg'));
+    print(solve_math_question(question_img));
+}

jaclang/tests/test_bugs.py

@@ -0,0 +1,19 @@
+"""Test Jac language generally."""
+
+from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.utils.test import TestCase
+
+
+class JacBugTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_impl_match_confusion_issue(self) -> None:
+        """Basic test for symtable support for inheritance."""
+        mypass = jac_file_to_pass(
+            self.fixture_abs_path("impl_match_confused.jac"),
+        )
+        self.assertEqual(len(mypass.errors_had), 1)

jaclang/tests/test_cli.py

@@ -112,7 +112,7 @@ class JacCliTests(TestCase):
         cli.tool("ir", ["ast", f"{self.fixture_abs_path('type_info.jac')}"])
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 6)
+        self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 7)
         self.assertEqual(stdout_value.count("builtins.int"), 2)
         self.assertEqual(stdout_value.count("builtins.str"), 7)
 

jaclang/tests/test_language.py

@@ -6,9 +6,12 @@ import pickle
 import sys
 import sysconfig
 
+
+import jaclang.compiler.passes.main as passes
 from jaclang import jac_import
 from jaclang.cli import cli
 from jaclang.compiler.compile import jac_file_to_pass, jac_pass_to_pass, jac_str_to_pass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.settings import settings
 from jaclang.utils.test import TestCase
@@ -109,91 +112,105 @@ class JacLanguageTests(TestCase):
             "{'a': 'apple', 'b': 'ball', 'c': 'cat', 'd': 'dog', 'e': 'elephant'}\n",
         )
 
-    def test_with_llm_function(self) -> None:
-        """Parse micro jac file."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("with_llm_function", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("{'temperature': 0.7}", stdout_value)
-        self.assertIn("Emoji Representation (str)", stdout_value)
-        self.assertIn('Text Input (input) (str) = "Lets move to paris"', stdout_value)
-        try:
-            self.assertIn(
-                "Examples of Text to Emoji (emoji_examples) (list[dict[str,str]])"
-                ' = [{"input": "I love tp drink pina coladas"',
-                stdout_value,
-            )
-        except AssertionError:
-            self.skipTest(
-                "This error only happens in certain enviornments, check later."
-            )
+    # TODO: Move these tests to mtllm repo
+    # def test_with_llm_function(self) -> None:
+    #     """Parse micro jac file."""
+    #     captured_output = io.StringIO()
+    #     sys.stdout = captured_output
+    #     jac_import("with_llm_function", base_path=self.fixture_abs_path("./"))
+    #     sys.stdout = sys.__stdout__
+    #     stdout_value = captured_output.getvalue()
+    #     self.assertIn("{'temperature': 0.7}", stdout_value)
+    #     self.assertIn("Emoji Representation (str)", stdout_value)
+    #     self.assertIn('Text Input (input) (str) = "Lets move to paris"', stdout_value)
+    #     self.assertIn(
+    #         ' = [{"input": "I love tp drink pina coladas"',
+    #         stdout_value,
+    #     )
 
-    def test_with_llm_method(self) -> None:
-        """Parse micro jac file."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("with_llm_method", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("[Reasoning] <Reason>", stdout_value)
-        self.assertIn("(Enum) eg:- Personality.EXTROVERT ->", stdout_value)
-        self.assertIn(
-            "Personality Index of a Person (PersonalityIndex) (class) eg:- "
-            "PersonalityIndex(index=int) -> Personality Index (index) (int)",
-            stdout_value,
-        )
-        self.assertIn(
-            "Personality of the Person (dict[Personality,PersonalityIndex])",
-            stdout_value,
-        )
-        self.assertIn(
-            'Diary Entries (diary_entries) (list[str]) = ["I won noble prize in '
-            'Physics", "I am popular for my theory of relativity"]',
-            stdout_value,
-        )
+    # def test_with_llm_method(self) -> None:
+    #     """Parse micro jac file."""
+    #     captured_output = io.StringIO()
+    #     sys.stdout = captured_output
+    #     jac_import("with_llm_method", base_path=self.fixture_abs_path("./"))
+    #     sys.stdout = sys.__stdout__
+    #     stdout_value = captured_output.getvalue()
+    #     self.assertIn("[Reasoning] <Reason>", stdout_value)
+    #     self.assertIn("(Enum) eg:- Personality.EXTROVERT ->", stdout_value)
+    #     self.assertIn(
+    #         "Personality Index of a Person (PersonalityIndex) (class) eg:- "
+    #         "PersonalityIndex(index=int) -> Personality Index (index) (int)",
+    #         stdout_value,
+    #     )
+    #     self.assertIn(
+    #         "Personality of the Person (dict[Personality,PersonalityIndex])",
+    #         stdout_value,
+    #     )
+    #     self.assertIn(
+    #         'Diary Entries (diary_entries) (list[str]) = ["I won noble prize in '
+    #         'Physics", "I am popular for my theory of relativity"]',
+    #         stdout_value,
+    #     )
 
-    def test_with_llm_lower(self) -> None:
-        """Parse micro jac file."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("with_llm_lower", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("[Reasoning] <Reason>", stdout_value)
-        self.assertIn(
-            'Name of the Person (name) (str) = "Oppenheimer"',
-            stdout_value,
-        )
-        self.assertIn(
-            "Person (Person) (obj) eg:- Person(full_name=str, yod=int, personality"
-            "=Personality) -> Fullname of the Person (full_name) (str), Year of Death"
-            " (yod) (int), Personality of the Person (personality) (Personality)",
-            stdout_value,
-        )
-        self.assertIn(
-            "J. Robert Oppenheimer was a Introvert person who died in 1967",
-            stdout_value,
-        )
+    # def test_with_llm_lower(self) -> None:
+    #     """Parse micro jac file."""
+    #     captured_output = io.StringIO()
+    #     sys.stdout = captured_output
+    #     jac_import("with_llm_lower", base_path=self.fixture_abs_path("./"))
+    #     sys.stdout = sys.__stdout__
+    #     stdout_value = captured_output.getvalue()
+    #     self.assertIn("[Reasoning] <Reason>", stdout_value)
+    #     self.assertIn(
+    #         'Name of the Person (name) (str) = "Oppenheimer"',
+    #         stdout_value,
+    #     )
+    #     self.assertIn(
+    #         "Person (Person) (obj) eg:- Person(full_name=str, yod=int, personality"
+    #         "=Personality) -> Fullname of the Person (full_name) (str), Year of Death"
+    #         " (yod) (int), Personality of the Person (personality) (Personality)",
+    #         stdout_value,
+    #     )
+    #     self.assertIn(
+    #         "J. Robert Oppenheimer was a Introvert person who died in 1967",
+    #         stdout_value,
+    #     )
 
-    def test_with_llm_type(self) -> None:
-        """Parse micro jac file."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("with_llm_type", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("14/03/1879", stdout_value)
-        self.assertNotIn(
-            'University (University) (obj) = type(__module__="with_llm_type", __doc__=None, '
-            "_jac_entry_funcs_=[], _jac_exit_funcs_=[], __init__=function(__wrapped__=function()))",
-            stdout_value,
-        )
-        desired_output_count = stdout_value.count(
-            "Person(name='Jason Mars', dob='1994-01-01', age=30)"
-        )
-        self.assertEqual(desired_output_count, 2)
+    # def test_with_llm_type(self) -> None:
+    #     """Parse micro jac file."""
+    #     captured_output = io.StringIO()
+    #     sys.stdout = captured_output
+    #     jac_import("with_llm_type", base_path=self.fixture_abs_path("./"))
+    #     sys.stdout = sys.__stdout__
+    #     stdout_value = captured_output.getvalue()
+    #     self.assertIn("14/03/1879", stdout_value)
+    #     self.assertNotIn(
+    #         'University (University) (obj) = type(__module__="with_llm_type", __doc__=None, '
+    #         "_jac_entry_funcs_`=[`], _jac_exit_funcs_=[], __init__=function(__wrapped__=function()))",
+    #         stdout_value,
+    #     )
+    #     desired_output_count = stdout_value.count(
+    #         "Person(name='Jason Mars', dob='1994-01-01', age=30)"
+    #     )
+    #     self.assertEqual(desired_output_count, 2)
+
+    # def test_with_llm_vision(self) -> None:
+    #     """Test MTLLLM Vision Implementation."""
+    #     try:
+    #         captured_output = io.StringIO()
+    #         sys.stdout = captured_output
+    #         jac_import("with_llm_vision", base_path=self.fixture_abs_path("./"))
+    #         sys.stdout = sys.__stdout__
+    #         stdout_value = captured_output.getvalue()
+    #         self.assertIn(
+    #             "{'type': 'text', 'text': '\\n[System Prompt]\\n", stdout_value[:500]
+    #         )
+    #         self.assertNotIn(
+    #             " {'type': 'text', 'text': 'Image of the Question (question_img) (Image) = '}, "
+    #             "{'type': 'image_url', 'image_url': {'url': 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQAB",
+    #             stdout_value[:500],
+    #         )
+    #     except Exception:
+    #         self.skipTest("This test requires Pillow to be installed.")
 
     def test_ignore(self) -> None:
         """Parse micro jac file."""
@@ -829,3 +846,101 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue()
         self.assertIn("Deep convo is imported", stdout_value)
         settings.py_raise = settings.py_raise_deep = False
+
+    def test_override_walker_inherit(self) -> None:
+        """Test py ast to Jac ast conversion output."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("walker_override", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual("baz\nbar\n", stdout_value)
+
+    def test_ds_type_check_pass(self) -> None:
+        """Test conn assign on edges."""
+        Jac.get_root()._jac_.edges.clear()
+        mypass = jac_file_to_pass(
+            self.fixture_abs_path("../../../examples/micro/simple_walk.jac"),
+            schedule=py_code_gen_typed,
+        )
+        self.assertEqual(len(mypass.errors_had), 0)
+        self.assertEqual(len(mypass.warnings_had), 0)
+
+    def test_ds_type_check_pass2(self) -> None:
+        """Test conn assign on edges."""
+        Jac.get_root()._jac_.edges.clear()
+        mypass = jac_file_to_pass(
+            self.fixture_abs_path("../../../examples/guess_game/guess_game5.jac"),
+            schedule=py_code_gen_typed,
+        )
+        self.assertEqual(len(mypass.errors_had), 0)
+        self.assertEqual(len(mypass.warnings_had), 0)
+
+    def test_self_with_no_sig(self) -> None:  # we can get rid of this, isn't?
+        """Test py ast to Jac ast conversion output."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("nosigself", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual(stdout_value.count("5"), 2)
+
+    def test_hash_init_check(self) -> None:  # we can get rid of this, isn't?
+        """Test py ast to Jac ast conversion output."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("hash_init_check", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Test Passed", stdout_value)
+
+    def test_multiline_single_tok(self) -> None:
+        """Test conn assign on edges."""
+        Jac.get_root()._jac_.edges.clear()
+        mypass = jac_file_to_pass(self.fixture_abs_path("byllmissue.jac"))
+        self.assertIn("2:5 - 4:8", mypass.ir.pp())
+
+    def test_single_impl_annex(self) -> None:
+        """Basic test for pass."""
+        mypass = jac_file_to_pass(
+            self.fixture_abs_path("../../../examples/manual_code/circle_pure.jac"),
+            target=passes.JacImportPass,
+        )
+
+        self.assertEqual(mypass.ir.pp().count("AbilityDef - (o)Circle.(c)area"), 1)
+        self.assertIsNone(mypass.ir._sym_tab)
+        mypass = jac_file_to_pass(
+            self.fixture_abs_path("../../../examples/manual_code/circle_pure.jac"),
+            target=passes.SymTabBuildPass,
+        )
+        self.assertEqual(
+            len([i for i in mypass.ir.sym_tab.kid if i.name == "circle_pure.impl"]),
+            1,
+        )
+
+    def test_inherit_baseclass_sym(self) -> None:
+        """Basic test for symtable support for inheritance."""
+        mypass = jac_file_to_pass(
+            self.fixture_abs_path("../../../examples/guess_game/guess_game4.jac"),
+            target=passes.DefUsePass,
+        )
+        table = None
+        for i in mypass.ir.sym_tab.kid:
+            print(i.name)
+            if i.name == "GuessTheNumberGame":
+                for j in i.kid:
+                    if j.name == "play":
+                        table = j
+                        break
+                break
+        self.assertIsNotNone(table)
+        self.assertIsNotNone(table.lookup("attempts"))
+
+    def test_edge_expr_not_type(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("edgetypeissue", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("[x()]", stdout_value)