jaclang 0.7.2__py3-none-any.whl → 0.7.8__py3-none-any.whl

jaclang/plugin/spec.py

@@ -3,19 +3,19 @@
 from __future__ import annotations
 
 import types
-from dataclasses import dataclass
 from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
 
 from jaclang.compiler.absyntree import Module
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import EdgeArchitype, NodeArchitype
+    from jaclang.core.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
         ExecutionContext,
         WalkerArchitype,
         Root,
+        DSFunc,
     )
     from jaclang.core.memory import Memory
 
@@ -26,20 +26,6 @@ hookspec = pluggy.HookspecMarker("jac")
 T = TypeVar("T")
 
 
-# TODO: DSFunc should be moved into jaclang/core
-@dataclass(eq=False)
-class DSFunc:
-    """Data Spatial Function."""
-
-    name: str
-    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
-    func: Callable[[Any, Any], Any] | None = None
-
-    def resolve(self, cls: type) -> None:
-        """Resolve the function."""
-        self.func = getattr(cls, self.name)
-
-
 class JacFeatureSpec:
     """Jac Feature."""
 
@@ -113,7 +99,7 @@ class JacFeatureSpec:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -167,7 +153,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         raise NotImplementedError
@@ -176,7 +168,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         raise NotImplementedError
@@ -248,7 +246,7 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""

jaclang/settings.py

@@ -18,6 +18,9 @@ class Settings:
     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

@@ -1,3 +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/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/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/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

@@ -7,9 +7,11 @@ 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
@@ -110,105 +112,6 @@ 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)
-        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_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_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()
@@ -857,7 +760,18 @@ class JacLanguageTests(TestCase):
         """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")
+            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)
@@ -879,3 +793,54 @@ class JacLanguageTests(TestCase):
         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)

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,17 +96,20 @@ 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):
-            out = 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_link.sym_path_str
-                    if node.sym_link
+                    node.sym.sym_dotted_name
+                    if node.sym
                     else "<No Symbol is associated with this node>"
                 )
                 out += f" SymbolPath: {symbol}"
@@ -114,11 +117,14 @@ def print_ast_tree(
         elif isinstance(node, Token):
             return f"{node.__class__.__name__} - {node.value}, {access}"
         elif isinstance(node, AstSymbolNode):
-            out = 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_link.sym_path_str
-                    if node.sym_link
+                    node.sym.sym_dotted_name
+                    if node.sym
                     else "<No Symbol is associated with this node>"
                 )
                 out += f" SymbolPath: {symbol}"
@@ -259,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.2.dist-info → jaclang-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.2
+Version: 0.7.8
 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