jaclang 0.7.17__tar.gz → 0.7.18__tar.gz

{jaclang-0.7.17 → jaclang-0.7.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.17
+Version: 0.7.18
 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
@@ -12,7 +12,9 @@ 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: all
 Provides-Extra: llm
+Provides-Extra: streamlit
 Project-URL: Documentation, https://jac-lang.org
 Project-URL: Repository, https://github.com/Jaseci-Labs/jaclang
 Description-Content-Type: text/markdown

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/cli/cli.py

@@ -8,7 +8,6 @@ import pickle
 import shutil
 import types
 from typing import Optional
-from uuid import UUID
 
 import jaclang.compiler.absyntree as ast
 from jaclang import jac_import
@@ -159,10 +158,9 @@ def get_object(
         raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
     data = {}
-    if id == "root":
-        data = jctx.root.__getstate__()
-    elif obj := jctx.mem.find_by_id(UUID(id)):
-        data = obj.__getstate__()
+    obj = Jac.get_object(id)
+    if obj:
+        data = obj.__jac__.__getstate__()
     else:
         print(f"Object with id {id} not found.")
 

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -2641,6 +2641,31 @@ class PyastGenPass(Pass):
             ]
         elif node.op.name in [Tok.STAR_POW]:
             node.gen.py_ast = node.operand.gen.py_ast
+        elif node.op.name in [Tok.BW_AND]:
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Attribute(
+                                value=self.sync(
+                                    ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                                ),
+                                attr="get_object",
+                                ctx=ast3.Load(),
+                            )
+                        ),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="id",
+                                    value=node.operand.gen.py_ast[0],
+                                )
+                            ),
+                        ],
+                    )
+                )
+            ]
         else:
             self.ice(f"Unknown Unary operator {node.op.value}")
 

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -1562,6 +1562,8 @@ class JacFormatPass(Pass):
             self.emit(node, f"not {node.operand.gen.jac}")
         elif node.op.name in [Tok.PIPE_FWD, Tok.KW_SPAWN, Tok.A_PIPE_FWD]:
             self.emit(node, f"{node.op.value} {node.operand.gen.jac}")
+        elif node.op.name in [Tok.BW_AND]:
+            self.emit(node, f"{node.op.value}{node.operand.gen.jac}")
         else:
             self.error(f"Unary operator {node.op.value} not supported in bootstrap Jac")
 

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/langserve/engine.py

@@ -22,8 +22,7 @@ from jaclang.langserve.utils import (
     find_deepest_symbol_node_at_pos,
     find_index,
     gen_diagnostics,
-    get_item_path,
-    get_mod_path,
+    get_location_range,
     get_symbols_for_outline,
     parse_symbol_path,
     resolve_completion_symbol_table,
@@ -335,8 +334,9 @@ class JacLangServer(LanguageServer):
                 and node_selected.parent
                 and isinstance(node_selected.parent, ast.ModulePath)
             ):
-                spec = get_mod_path(node_selected.parent, node_selected)
+                spec = node_selected.parent.abs_path
                 if spec:
+                    spec = spec[5:] if spec.startswith("File:") else spec
                     return lspt.Location(
                         uri=uris.from_fs_path(spec),
                         range=lspt.Range(
@@ -349,19 +349,28 @@ class JacLangServer(LanguageServer):
             elif node_selected.parent and isinstance(
                 node_selected.parent, ast.ModuleItem
             ):
-                path_range = get_item_path(node_selected.parent)
-                if path_range:
-                    path, loc_range = path_range
-                    if path and loc_range:
-                        return lspt.Location(
-                            uri=uris.from_fs_path(path),
-                            range=lspt.Range(
-                                start=lspt.Position(line=loc_range[0], character=0),
-                                end=lspt.Position(line=loc_range[1], character=5),
+                path = node_selected.parent.from_mod_path.abs_path
+                try:  # TODO: Get rid of this when 'from' import is fixed
+                    loc_range = tuple(
+                        loc - 1 if loc > 0 else loc
+                        for loc in get_location_range(node_selected.parent)
+                    )
+                except ValueError:
+                    loc_range = (0, 0, 0, 0)
+
+                if path and loc_range:
+                    path = path[5:] if path.startswith("File:") else path
+                    return lspt.Location(
+                        uri=uris.from_fs_path(path),
+                        range=lspt.Range(
+                            start=lspt.Position(
+                                line=loc_range[0], character=loc_range[1]
                             ),
-                        )
-                else:
-                    return None
+                            end=lspt.Position(
+                                line=loc_range[2], character=loc_range[3]
+                            ),
+                        ),
+                    )
             elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
                 return None
             decl_node = (
@@ -378,7 +387,7 @@ class JacLangServer(LanguageServer):
             decl_uri = uris.from_fs_path(decl_node.loc.mod_path)
             try:
                 decl_range = create_range(decl_node.loc)
-            except ValueError:  # 'print' name has decl in 0,0,0,0
+            except ValueError:
                 return None
             decl_location = lspt.Location(
                 uri=decl_uri,

jaclang-0.7.18/jaclang/langserve/tests/fixtures/import_include_statements.jac

@@ -0,0 +1,6 @@
+import:py os;
+import:py from math{ sqrt as square_root}
+import:py datetime as dt;
+import:jac from base_module_structure{ add as add_numbers , subtract,x,Colorenum as clr}
+import:jac base_module_structure as base_module_structure;
+import:py from py_import{add1 as ss, sub1 as subtract1,apple,Orange1}

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/langserve/tests/test_server.py

@@ -187,11 +187,15 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (2, 24, "datetime.py:0:0-0:0"),
+            (0, 12, "tdlib/os/__init__.pyi:0:0-0:0"),
+            (1, 18, "stdlib/math.pyi:0:0-0:0"),
+            (2, 24, "datetime.pyi:0:0-0:0"),
             (3, 17, "base_module_structure.jac:0:0-0:0"),
-            (3, 87, "base_module_structure.jac:23:0-23:5"),
-            (5, 65, "py_import.py:12:0-20:5"),
-            (5, 35, "py_import.py:3:0-4:5"),
+            (3, 87, "base_module_structure.jac:23:5-23:14"),
+            (5, 65, "py_import.py:0:0-0:0"),
+            (5, 35, "py_import.py:0:0-0:0"),
+            # (5, 65, "py_import.py:12:0-20:5"),  # TODO : Should work after 'from' import files are raised
+            # (5, 35, "py_import.py:3:0-4:5"),
         ]
 
         for line, char, expected in positions:

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/langserve/utils.py

@@ -2,10 +2,7 @@
 
 import asyncio
 import builtins
-import importlib.util
-import os
 import re
-import sys
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
@@ -209,6 +206,17 @@ def create_range(loc: CodeLocInfo) -> lspt.Range:
     )
 
 
+def get_location_range(mod_item: ast.ModuleItem) -> tuple[int, int, int, int]:
+    """Get location range."""
+    if not mod_item.from_mod_path.sub_module:
+        raise ValueError("Module items should have module path. Not Possible.")
+    lookup = mod_item.from_mod_path.sub_module.sym_tab.lookup(mod_item.name.value)
+    if not lookup:
+        raise ValueError("Module items should have a symbol table entry. Not Possible.")
+    loc = lookup.decl.loc
+    return loc.first_line, loc.col_start, loc.last_line, loc.col_end
+
+
 def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
     """Map the symbol node to an lspt.SymbolKind."""
     return (
@@ -273,103 +281,6 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind:
     )
 
 
-def get_mod_path(
-    mod_path: ast.ModulePath, name_node: ast.Name
-) -> str | None:  # TODO: This should go away
-    """Get path for a module import name."""
-    ret_target = None
-    if mod_path.parent and (
-        (
-            isinstance(mod_path.parent.parent, ast.Import)
-            and mod_path.parent.parent.is_py
-        )
-        or (
-            isinstance(mod_path.parent, ast.Import)
-            and mod_path.parent.from_loc
-            and mod_path.parent.is_py
-        )
-    ):
-        if mod_path.path and name_node in mod_path.path:
-            temporary_path_str = ("." * mod_path.level) + ".".join(
-                [p.value for p in mod_path.path[: mod_path.path.index(name_node) + 1]]
-                if mod_path.path
-                else ""
-            )
-        else:
-            temporary_path_str = mod_path.dot_path_str
-        sys.path.append(os.path.dirname(mod_path.loc.mod_path))
-        spec = importlib.util.find_spec(temporary_path_str)
-        sys.path.remove(os.path.dirname(mod_path.loc.mod_path))
-        if spec and spec.origin and spec.origin.endswith(".py"):
-            ret_target = spec.origin
-    elif mod_path.parent and (
-        (
-            isinstance(mod_path.parent.parent, ast.Import)
-            and mod_path.parent.parent.is_jac
-        )
-        or (
-            isinstance(mod_path.parent, ast.Import)
-            and mod_path.parent.from_loc
-            and mod_path.parent.is_jac
-        )
-    ):
-        ret_target = mod_path.resolve_relative_path()
-    return ret_target
-
-
-def get_item_path(mod_item: ast.ModuleItem) -> tuple[str, tuple[int, int]] | None:
-    """Get path."""
-    item_name = mod_item.name.value
-    if mod_item.from_parent.is_py and mod_item.from_parent.from_loc:
-        path = get_mod_path(mod_item.from_parent.from_loc, mod_item.name)
-        if path:
-            return get_definition_range(path, item_name)
-    elif mod_item.from_parent.is_jac:
-        mod_node = mod_item.from_mod_path
-        if mod_node.sub_module and mod_node.sub_module._sym_tab:
-            for symbol_name, symbol in mod_node.sub_module._sym_tab.tab.items():
-                if symbol_name == item_name:
-                    return symbol.decl.loc.mod_path, (
-                        symbol.decl.loc.first_line - 1,
-                        symbol.decl.loc.last_line - 1,
-                    )
-    return None
-
-
-def get_definition_range(
-    filename: str, name: str
-) -> tuple[str, tuple[int, int]] | None:
-    """Get the start and end line of a function or class definition in a file."""
-    import ast
-
-    with open(filename, "r") as file:
-        source = file.read()
-
-    tree = ast.parse(source)
-
-    for node in ast.walk(tree):
-        if isinstance(node, (ast.FunctionDef, ast.ClassDef)) and node.name == name:
-            start_line = node.lineno
-            end_line = (
-                node.body[-1].end_lineno
-                if hasattr(node.body[-1], "end_lineno")
-                else node.body[-1].lineno
-            )
-            if start_line and end_line:
-                return filename, (start_line - 1, end_line - 1)
-        elif isinstance(node, ast.Assign):
-            for target in node.targets:
-                if isinstance(target, ast.Name) and target.id == name:
-                    start_line = node.lineno
-                    end_line = (
-                        node.end_lineno if hasattr(node, "end_lineno") else node.lineno
-                    )
-                    if start_line and end_line:
-                        return filename, (start_line - 1, end_line - 1)
-
-    return None
-
-
 def collect_all_symbols_in_scope(
     sym_tab: SymbolTable, up_tree: bool = True
 ) -> list[lspt.CompletionItem]:

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/plugin/builtin.py

@@ -2,11 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import Optional
 
-if TYPE_CHECKING:
-    from typing import Optional
-    from jaclang.runtimelib.constructs import NodeArchitype
+from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.constructs import Architype, NodeArchitype
 
 
 def dotgen(
@@ -40,3 +39,8 @@ def dotgen(
         node_limit=node_limit,
         dot_file=dot_file,
     )
+
+
+def jid(obj: Architype) -> str:
+    """Get the id of the object."""
+    return Jac.object_ref(obj)

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/plugin/default.py

@@ -12,13 +12,13 @@ from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 from typing import Any, Callable, Mapping, Optional, Sequence, Type, Union
+from uuid import UUID
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import EdgeDir, colors
 from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
 from jaclang.runtimelib.constructs import (
-    Anchor,
     Architype,
     DSFunc,
     EdgeAnchor,
@@ -44,7 +44,6 @@ import pluggy
 hookimpl = pluggy.HookimplMarker("jac")
 
 __all__ = [
-    "Anchor",
     "EdgeAnchor",
     "GenericEdge",
     "hookimpl",
@@ -72,6 +71,21 @@ class JacFeatureDefaults:
         """Get current execution context."""
         return ExecutionContext.get()
 
+    @staticmethod
+    @hookimpl
+    def get_object(id: str) -> Architype | None:
+        if id == "root":
+            return Jac.get_context().root.architype
+        elif obj := Jac.get_context().mem.find_by_id(UUID(id)):
+            return obj.architype
+
+        return None
+
+    @staticmethod
+    @hookimpl
+    def object_ref(obj: Architype) -> str:
+        return obj.__jac__.id.hex
+
     @staticmethod
     @hookimpl
     def make_architype(
@@ -903,7 +917,7 @@ class JacBuiltin:
         for source, target, edge in connections:
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{html.escape(str(edge.__jac__.architype.__class__.__name__))} "];\n'
+                f' [label="{html.escape(str(edge.__jac__.architype))} "];\n'
             )
         for node_ in visited_nodes:
             color = (

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/plugin/feature.py

@@ -46,6 +46,16 @@ class JacFeature:
         """Get current execution context."""
         return pm.hook.get_context()
 
+    @staticmethod
+    def get_object(id: str) -> Architype | None:
+        """Get object given id."""
+        return pm.hook.get_object(id=id)
+
+    @staticmethod
+    def object_ref(obj: Architype) -> str:
+        """Get object reference id."""
+        return pm.hook.object_ref(obj=obj)
+
     @staticmethod
     def make_architype(
         cls: type,

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/plugin/spec.py

@@ -48,6 +48,18 @@ class JacFeatureSpec:
         """Get current execution context."""
         raise NotImplementedError
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_object(id: str) -> Architype | None:
+        """Get object given id.."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def object_ref(obj: Architype) -> str:
+        """Get object given id.."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def make_architype(

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/runtimelib/importer.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import importlib
+import importlib.util
 import os
 import sys
 import types

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/runtimelib/memory.py

@@ -18,7 +18,7 @@ class Memory(Generic[ID, TANCH]):
     """Generic Memory Handler."""
 
     __mem__: dict[ID, TANCH] = field(default_factory=dict)
-    __gc__: set[ID] = field(default_factory=set)
+    __gc__: set[TANCH] = field(default_factory=set)
 
     def close(self) -> None:
         """Close memory handler."""
@@ -62,8 +62,8 @@ class Memory(Generic[ID, TANCH]):
             ids = [ids]
 
         for id in ids:
-            self.__mem__.pop(id, None)
-            self.__gc__.add(id)
+            if anchor := self.__mem__.pop(id, None):
+                self.__gc__.add(anchor)
 
 
 @dataclass
@@ -84,9 +84,9 @@ class ShelfStorage(Memory[UUID, Anchor]):
 
             root = Jac.get_root().__jac__
 
-            for id in self.__gc__:
-                self.__shelf__.pop(str(id), None)
-                self.__mem__.pop(id, None)
+            for anchor in self.__gc__:
+                self.__shelf__.pop(str(anchor.id), None)
+                self.__mem__.pop(anchor.id, None)
 
             for d in self.__mem__.values():
                 if d.persistent and d.hash != hash(dumps(d)):

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/tests/fixtures/builtin_dotgen.jac

@@ -31,6 +31,7 @@ with entry{
     print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('GenericEdge')==42);
     print(d3.count('a(val')==6,d3.count("GenericEdge")==5,d3.count('#F5E5FF')==1);
     print(d4.count("a(val")==25,d4.count("GenericEdge")==66,d4.count('#FFF0F')==3);
+    print(d5.count("Edge1(val=6)")==2, d5.count("GenericEdge()")==24);
     # print(l3<l2);
     # print(d1);
     # print(d2);

jaclang-0.7.18/jaclang/tests/fixtures/objref.jac

@@ -0,0 +1,12 @@
+node MyNode {
+    has value: int = 0;
+}
+
+with entry {
+    root ++> (x:=MyNode());
+    obj_id = jid(x);
+    myobj = &obj_id;
+    print(obj_id);
+    print(myobj);
+    print("valid:", myobj == x);
+}

{jaclang-0.7.17 → jaclang-0.7.18}/jaclang/tests/test_language.py

@@ -39,7 +39,7 @@ class JacLanguageTests(TestCase):
         sys.stdout = captured_output
 
         # Execute the function
-        cli.run(self.fixture_abs_path("sub_abil_sep.jac"))  # type: ignore
+        cli.run(self.fixture_abs_path("sub_abil_sep.jac"))
 
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -376,7 +376,7 @@ class JacLanguageTests(TestCase):
         jac_import("builtin_dotgen", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual(stdout_value.count("True"), 14)
+        self.assertEqual(stdout_value.count("True"), 16)
 
     def test_with_contexts(self) -> None:
         """Test walking through edges."""
@@ -951,3 +951,14 @@ class JacLanguageTests(TestCase):
         self.assertIn("Edges in bar:\n  - Edge: Link", stdout_value)
         self.assertIn("Item value: 0", stdout_value)
         self.assertIn("Created 5 items.", stdout_value)
+
+    def test_object_ref_interface(self) -> None:
+        """Test class method output."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("objref.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual(len(stdout_value[0]), 32)
+        self.assertEqual("MyNode(value=0)", stdout_value[1])
+        self.assertEqual("valid: True", stdout_value[2])

{jaclang-0.7.17 → jaclang-0.7.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jaclang"
-version = "0.7.17"
+version = "0.7.18"
 description = "Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding."
 authors = ["Jason Mars <jason@jaseci.org>"]
 license = "MIT"
@@ -31,6 +31,8 @@ jac = "jaclang.cli.cli:start_cli"
 
 [tool.poetry.extras]
 llm = ["mtllm"]
+streamlit = ["jaclang-streamlit"]
+all = ["mtllm", "jaclang-streamlit"]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.2.1"

jaclang-0.7.17/jaclang/langserve/tests/fixtures/import_include_statements.jac

@@ -1,6 +0,0 @@
-import:py os;
-import:py from math, sqrt as square_root;
-import:py datetime as dt;
-import:jac from base_module_structure, add as add_numbers , subtract,x,Colorenum as clr;
-import:jac base_module_structure as base_module_structure;
-import:py from py_import,add1 as ss, sub1 as subtract1,apple,Orange1;