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

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/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_vision.jac

@@ -0,0 +1,25 @@
+import:py from jaclang.core.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
@@ -119,16 +122,10 @@ class JacLanguageTests(TestCase):
         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."
-            )
+        self.assertIn(
+            ' = [{"input": "I love tp drink pina coladas"',
+            stdout_value,
+        )
 
     def test_with_llm_method(self) -> None:
         """Parse micro jac file."""
@@ -187,7 +184,7 @@ class JacLanguageTests(TestCase):
         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()))",
+            "_jac_entry_funcs_`=[`], _jac_exit_funcs_=[], __init__=function(__wrapped__=function()))",
             stdout_value,
         )
         desired_output_count = stdout_value.count(
@@ -195,6 +192,25 @@ class JacLanguageTests(TestCase):
         )
         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."""
         Jac.get_root()._jac_.edges.clear()
@@ -829,3 +845,92 @@ 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"))

jaclang/tests/test_reference.py

@@ -66,7 +66,7 @@ class JacReferenceTests(TestCase):
             return f.getvalue()
 
         try:
-            if "tests.jac" in filename:
+            if "tests.jac" in filename or "check_statements.jac" in filename:
                 return
             jacast = jac_file_to_pass(filename).ir
             code_content = compile(

jaclang/utils/lang_tools.py

@@ -9,6 +9,7 @@ from typing import List, Optional, Type
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
+from jaclang.compiler.passes.main.schedules import py_code_gen, type_checker_sched
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.symtable import SymbolTable
 from jaclang.utils.helpers import auto_generate_refs, pascal_to_snake
@@ -81,8 +82,8 @@ class AstTool:
                 "JacSource",
                 "EmptyToken",
                 "AstSymbolNode",
+                "AstSymbolStubNode",
                 "AstAccessNode",
-                "TokenSymbol",
                 "Literal",
                 "AstDocNode",
                 "AstSemStrNode",
@@ -97,7 +98,7 @@ class AstTool:
                 "ArchBlockStmt",
                 "EnumBlockStmt",
                 "CodeBlockStmt",
-                "NameSpec",
+                "NameAtom",
                 "ArchSpec",
                 "MatchPattern",
             ]
@@ -234,8 +235,8 @@ class AstTool:
                     return f"Error While Jac to Py AST conversion: {e}"
             else:
                 ir = jac_file_to_pass(
-                    file_name, schedule=py_code_gen_typed
-                ).ir  # Assuming jac_file_to_pass is defined elsewhere
+                    file_name, schedule=[*(py_code_gen[:-1]), *type_checker_sched]
+                ).ir
 
             match output:
                 case "sym":

jaclang/utils/test.py

@@ -107,6 +107,7 @@ class AstSyncTestMixin:
                 "jac_source",
                 "empty_token",
                 "ast_symbol_node",
+                "ast_symbol_stub_node",
                 "ast_impl_needing_node",
                 "ast_access_node",
                 "token_symbol",
@@ -124,7 +125,7 @@ class AstSyncTestMixin:
                 "arch_block_stmt",
                 "enum_block_stmt",
                 "code_block_stmt",
-                "name_spec",
+                "name_atom",
                 "arch_spec",
                 "match_pattern",
             ]

jaclang/utils/treeprinter.py

@@ -96,16 +96,39 @@ def print_ast_tree(
             else ""
         )
         sym_table_link = (
-            f"SymbolTable: {node.sym_info.typ_sym_table.name}"
-            if isinstance(node, AstSymbolNode) and node.sym_info.typ_sym_table
+            f"SymbolTable: {node.type_sym_tab.name}"
+            if isinstance(node, AstSymbolNode) and node.type_sym_tab
             else "SymbolTable: None" if isinstance(node, AstSymbolNode) else ""
         )
+
         if isinstance(node, Token) and isinstance(node, AstSymbolNode):
-            return f"{node.__class__.__name__} - {node.value} - Type: {node.sym_info.typ}, {access} {sym_table_link}"
+            out = (
+                f"{node.__class__.__name__} - {node.value} - "
+                f"Type: {node.sym_type}, {access} {sym_table_link}"
+            )
+            if settings.ast_symbol_info_detailed:
+                symbol = (
+                    node.sym.sym_dotted_name
+                    if node.sym
+                    else "<No Symbol is associated with this node>"
+                )
+                out += f" SymbolPath: {symbol}"
+            return out
         elif isinstance(node, Token):
             return f"{node.__class__.__name__} - {node.value}, {access}"
         elif isinstance(node, AstSymbolNode):
-            return f"{node.__class__.__name__} - {node.sym_name} - Type: {node.sym_info.typ}, {access} {sym_table_link}"
+            out = (
+                f"{node.__class__.__name__} - {node.sym_name} - "
+                f"Type: {node.sym_type}, {access} {sym_table_link}"
+            )
+            if settings.ast_symbol_info_detailed:
+                symbol = (
+                    node.sym.sym_dotted_name
+                    if node.sym
+                    else "<No Symbol is associated with this node>"
+                )
+                out += f" SymbolPath: {symbol}"
+            return out
         else:
             return f"{node.__class__.__name__}, {access}"
 
@@ -242,6 +265,14 @@ def _build_symbol_tree_common(
                 )
                 for n in sym.defn
             ]
+            uses = SymbolTree(node_name="uses", parent=symbol_node)
+            [
+                SymbolTree(
+                    node_name=f"line {n.loc.first_line}, col {n.loc.col_start}",
+                    parent=uses,
+                )
+                for n in sym.uses
+            ]
 
     for k in node.kid:
         _build_symbol_tree_common(k, children)

{jaclang-0.7.1.dist-info → jaclang-0.7.5.dist-info}/METADATA

@@ -1,15 +1,16 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.1
+Version: 0.7.5
 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
 Keywords: jac,jaclang,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
 Author-email: jason@jaseci.org
-Requires-Python: >=3.12.0,<4.0.0
+Requires-Python: >=3.11.0,<4.0.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: llm
 Project-URL: Documentation, https://jac-lang.org