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

jaclang/langserve/utils.py

@@ -1,12 +1,15 @@
 """Utility functions for the language server."""
 
 import asyncio
+import builtins
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.symtable import SymbolTable
+from jaclang.compiler.codeloc import CodeLocInfo
+from jaclang.compiler.symtable import Symbol, SymbolTable
 
+import lsprotocol.types as lspt
 
 T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
 P = ParamSpec("P")
@@ -55,17 +58,23 @@ def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]:
     return sym_tabs
 
 
-def find_deepest_node_at_pos(
+def find_deepest_symbol_node_at_pos(
     node: ast.AstNode, line: int, character: int
-) -> Optional[ast.AstNode]:
-    """Return the deepest node that contains the given position."""
+) -> Optional[ast.AstSymbolNode]:
+    """Return the deepest symbol node that contains the given position."""
+    last_symbol_node = None
+
     if position_within_node(node, line, character):
-        for i in node.kid:
-            if position_within_node(i, line, character):
-                return find_deepest_node_at_pos(i, line, character)
-        return node
-    else:
-        return None
+        if isinstance(node, ast.AstSymbolNode):
+            last_symbol_node = node
+
+        for child in node.kid:
+            if position_within_node(child, line, character):
+                deeper_node = find_deepest_symbol_node_at_pos(child, line, character)
+                if deeper_node is not None:
+                    last_symbol_node = deeper_node
+
+    return last_symbol_node
 
 
 def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
@@ -88,3 +97,84 @@ def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
     ):
         return True
     return False
+
+
+def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
+    """Recursively collect symbols from the AST."""
+    symbols = []
+    if node is None:
+        return symbols
+
+    for key, item in node.tab.items():
+        if key in dir(builtins):
+            continue
+        if item in [owner_sym(tab) for tab in node.kid]:
+            continue
+        else:
+
+            pos = create_range(item.defn[0].loc)
+            symbol = lspt.DocumentSymbol(
+                name=key,
+                kind=kind_map(item.defn[0]),
+                range=pos,
+                selection_range=pos,
+                children=[],
+            )
+            symbols.append(symbol)
+
+    for sub_tab in node.kid:
+        sub_symbols = collect_symbols(sub_tab)
+
+        if isinstance(
+            sub_tab.owner,
+            (ast.IfStmt, ast.ElseStmt, ast.WhileStmt, ast.IterForStmt, ast.InForStmt),
+        ):
+            symbols.extend(sub_symbols)
+        else:
+            sub_pos = create_range(sub_tab.owner.loc)
+            symbol = lspt.DocumentSymbol(
+                name=sub_tab.name,
+                kind=kind_map(sub_tab.owner),
+                range=sub_pos,
+                selection_range=sub_pos,
+                children=sub_symbols,
+            )
+            symbols.append(symbol)
+
+    return symbols
+
+
+def owner_sym(table: SymbolTable) -> Optional[Symbol]:
+    """Get owner sym."""
+    if table.has_parent() and isinstance(table.owner, ast.AstSymbolNode):
+        return table.parent.lookup(table.owner.sym_name)
+    return None
+
+
+def create_range(loc: CodeLocInfo) -> lspt.Range:
+    """Create an lspt.Range from a location object."""
+    return lspt.Range(
+        start=lspt.Position(line=loc.first_line - 1, character=loc.col_start - 1),
+        end=lspt.Position(line=loc.last_line - 1, character=loc.col_end - 1),
+    )
+
+
+def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
+    """Map the symbol node to an lspt.SymbolKind."""
+    return (
+        lspt.SymbolKind.Function
+        if isinstance(sub_tab, (ast.Ability, ast.AbilityDef))
+        else (
+            lspt.SymbolKind.Class
+            if isinstance(sub_tab, (ast.Architype, ast.ArchDef))
+            else (
+                lspt.SymbolKind.Module
+                if isinstance(sub_tab, ast.Module)
+                else (
+                    lspt.SymbolKind.Enum
+                    if isinstance(sub_tab, (ast.Enum, ast.EnumDef))
+                    else lspt.SymbolKind.Variable
+                )
+            )
+        )
+    )

jaclang/plugin/default.py

@@ -7,11 +7,10 @@ import html
 import os
 import pickle
 import types
-from contextvars import ContextVar
+from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 from typing import Any, Callable, Optional, Type, Union
-from uuid import UUID
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
@@ -20,27 +19,27 @@ from jaclang.core.aott import (
     extract_non_primary_type,
     get_all_type_explanations,
     get_info_types,
-    get_object_string,
-    get_type_annotation,
+    get_input_information,
 )
 from jaclang.core.construct import (
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
+    ExecutionContext,
     GenericEdge,
     JacTestCheck,
+    Memory,
     NodeAnchor,
     NodeArchitype,
     ObjectAnchor,
     Root,
     WalkerAnchor,
     WalkerArchitype,
+    exec_context,
 )
 from jaclang.core.importer import jac_importer
-from jaclang.core.memory import Memory
 from jaclang.core.registry import SemInfo, SemRegistry, SemScope
-from jaclang.core.shelve_storage import ShelveStorage
 from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
@@ -70,65 +69,6 @@ __all__ = [
 hookimpl = pluggy.HookimplMarker("jac")
 
 
-class ExecutionContext:
-    """Default Execution Context implementation."""
-
-    mem: Optional[Memory]
-    root: Optional[Root]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.mem = ShelveStorage()
-        self.root = None
-
-    def init_memory(self, session: str = "") -> None:
-        if session:
-            self.mem = ShelveStorage(session)
-        else:
-            self.mem = Memory()
-
-    def get_root(self) -> Root:
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        if not self.root:
-            root = self.mem.get_obj(UUID(int=0))
-            if root is None:
-                self.root = Root()
-                self.mem.save_obj(self.root, persistent=self.root._jac_.persistent)
-            elif not isinstance(root, Root):
-                raise ValueError(f"Invalid root object: {root}")
-            else:
-                self.root = root
-        return self.root
-
-    def get_obj(self, obj_id: UUID) -> Architype | None:
-        """Get object from memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        return self.mem.get_obj(obj_id)
-
-    def save_obj(self, item: Architype, persistent: bool) -> None:
-        """Save object to memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        self.mem.save_obj(item, persistent)
-
-    def reset(self) -> None:
-        """Reset the execution context."""
-        if self.mem:
-            self.mem.close()
-        self.mem = None
-        self.root = None
-
-
-ExecContext: ContextVar[ExecutionContext | None] = ContextVar(
-    "ExecutionContext", default=None
-)
-
-
 class JacFeatureDefaults:
     """Jac Feature."""
 
@@ -138,20 +78,20 @@ class JacFeatureDefaults:
     @hookimpl
     def context(session: str = "") -> ExecutionContext:
         """Get the execution context."""
-        ctx = ExecContext.get()
+        ctx = exec_context.get()
         if ctx is None:
             ctx = ExecutionContext()
-            ExecContext.set(ctx)
+            exec_context.set(ctx)
         return ctx
 
     @staticmethod
     @hookimpl
     def reset_context() -> None:
         """Reset the execution context."""
-        ctx = ExecContext.get()
+        ctx = exec_context.get()
         if ctx:
             ctx.reset()
-        ExecContext.set(None)
+        exec_context.set(None)
 
     @staticmethod
     @hookimpl
@@ -179,12 +119,20 @@ class JacFeatureDefaults:
             cls._jac_entry_funcs_ = on_entry  # type: ignore
             cls._jac_exit_funcs_ = on_exit  # type: ignore
         else:
-            cls._jac_entry_funcs_ = cls._jac_entry_funcs_ + [
-                x for x in on_entry if x not in cls._jac_entry_funcs_
-            ]
-            cls._jac_exit_funcs_ = cls._jac_exit_funcs_ + [
-                x for x in on_exit if x not in cls._jac_exit_funcs_
-            ]
+            new_entry_funcs = OrderedDict(zip([i.name for i in on_entry], on_entry))
+            entry_funcs = OrderedDict(
+                zip([i.name for i in cls._jac_entry_funcs_], cls._jac_entry_funcs_)
+            )
+            entry_funcs.update(new_entry_funcs)
+            cls._jac_entry_funcs_ = list(entry_funcs.values())
+
+            new_exit_funcs = OrderedDict(zip([i.name for i in on_exit], on_exit))
+            exit_funcs = OrderedDict(
+                zip([i.name for i in cls._jac_exit_funcs_], cls._jac_exit_funcs_)
+            )
+            exit_funcs.update(new_exit_funcs)
+            cls._jac_exit_funcs_ = list(exit_funcs.values())
+
         inner_init = cls.__init__  # type: ignore
 
         @wraps(inner_init)
@@ -698,14 +646,8 @@ class JacFeatureDefaults:
         incl_info = [x for x in incl_info if not isinstance(x[1], type)]
         information, collected_types = get_info_types(_scope, mod_registry, incl_info)
         type_collector.extend(collected_types)
-        inputs_information_list = []
-        for i in inputs:
-            typ_anno = get_type_annotation(i[3])
-            type_collector.extend(extract_non_primary_type(typ_anno))
-            inputs_information_list.append(
-                f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}"
-            )
-        inputs_information = "\n".join(inputs_information_list)
+
+        inputs_information = get_input_information(inputs, type_collector)
 
         output_information = f"{outputs[0]} ({outputs[1]})"
         type_collector.extend(extract_non_primary_type(outputs[1]))

jaclang/plugin/feature.py

@@ -3,22 +3,20 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, TYPE_CHECKING, Type, Union
+from typing import Any, Callable, Optional, Type, Union
 
 from jaclang.compiler.absyntree import Module
+from jaclang.core.construct import (
+    Architype,
+    EdgeArchitype,
+    Memory,
+    NodeArchitype,
+    Root,
+    WalkerArchitype,
+)
+from jaclang.plugin.default import ExecutionContext
 from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, T
 
-if TYPE_CHECKING:
-    from jaclang.core.construct import (
-        Architype,
-        EdgeArchitype,
-        NodeArchitype,
-        WalkerArchitype,
-        Root,
-    )
-    from jaclang.plugin.default import ExecutionContext
-    from jaclang.core.memory import Memory
-
 
 import pluggy
 

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,6 +12,7 @@ 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

jaclang/tests/fixtures/byllmissue.jac

@@ -0,0 +1,3 @@
+with entry {
+    my_thing = YourThing(level=thingy by llm());
+}

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/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/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_language.py

@@ -6,6 +6,7 @@ import pickle
 import sys
 import sysconfig
 
+
 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
@@ -119,16 +120,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 +182,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 +190,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 +843,39 @@ 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")
+        )
+        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)

jaclang/utils/treeprinter.py

@@ -100,12 +100,29 @@ def print_ast_tree(
             if isinstance(node, AstSymbolNode) and node.sym_info.typ_sym_table
             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} - Type: {node.sym_info.typ}, {access} {sym_table_link}"
+            if settings.ast_symbol_info_detailed:
+                symbol = (
+                    node.sym_link.sym_path_str
+                    if node.sym_link
+                    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} - Type: {node.sym_info.typ}, {access} {sym_table_link}"
+            if settings.ast_symbol_info_detailed:
+                symbol = (
+                    node.sym_link.sym_path_str
+                    if node.sym_link
+                    else "<No Symbol is associated with this node>"
+                )
+                out += f" SymbolPath: {symbol}"
+            return out
         else:
             return f"{node.__class__.__name__}, {access}"
 

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

@@ -1,15 +1,16 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.1
+Version: 0.7.2
 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