jaclang 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

jaclang/compiler/unitree.py

@@ -2167,7 +2167,7 @@ class HasVar(AstSymbolNode, AstTypedVarNode):
         return res
 
 
-class TypedCtxBlock(CodeBlockStmt, UniScopeNode):
+class TypedCtxBlock(CodeBlockStmt, WalkerStmtOnlyNode, UniScopeNode):
     """TypedCtxBlock node type for Jac Ast."""
 
     def __init__(
@@ -2181,6 +2181,7 @@ class TypedCtxBlock(CodeBlockStmt, UniScopeNode):
         UniNode.__init__(self, kid=kid)
         UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
         CodeBlockStmt.__init__(self)
+        WalkerStmtOnlyNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -3229,13 +3230,21 @@ class FString(AtomExpr):
             for part in self.parts:
                 res = res and part.normalize(deep)
         new_kid: list[UniNode] = []
-        is_single_quote = (
-            isinstance(self.kid[0], Token) and self.kid[0].name == Tok.FSTR_SQ_START
-        )
-        if is_single_quote:
-            new_kid.append(self.gen_token(Tok.FSTR_SQ_START))
+        # Determine quote type from first token
+        start_token = self.kid[0] if isinstance(self.kid[0], Token) else None
+        if start_token:
+            if start_token.name == Tok.FSTR_SQ_TRIPLE_START:
+                start_tok, end_tok = Tok.FSTR_SQ_TRIPLE_START, Tok.FSTR_SQ_TRIPLE_END
+            elif start_token.name == Tok.FSTR_TRIPLE_START:
+                start_tok, end_tok = Tok.FSTR_TRIPLE_START, Tok.FSTR_TRIPLE_END
+            elif start_token.name == Tok.FSTR_SQ_START:
+                start_tok, end_tok = Tok.FSTR_SQ_START, Tok.FSTR_SQ_END
+            else:
+                start_tok, end_tok = Tok.FSTR_START, Tok.FSTR_END
         else:
-            new_kid.append(self.gen_token(Tok.FSTR_START))
+            start_tok, end_tok = Tok.FSTR_START, Tok.FSTR_END
+
+        new_kid.append(self.gen_token(start_tok))
         for i in self.parts:
             if isinstance(i, String):
                 i.value = (
@@ -3246,10 +3255,7 @@ class FString(AtomExpr):
                 new_kid.append(self.gen_token(Tok.LBRACE))
                 new_kid.append(i)
                 new_kid.append(self.gen_token(Tok.RBRACE))
-        if is_single_quote:
-            new_kid.append(self.gen_token(Tok.FSTR_SQ_END))
-        else:
-            new_kid.append(self.gen_token(Tok.FSTR_END))
+        new_kid.append(self.gen_token(end_tok))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -3712,7 +3718,10 @@ class FuncCall(Expr):
             res = self.target.normalize(deep)
             for prm in self.params:
                 res = res and prm.normalize(deep)
-        new_kids = [self.target, self.gen_token(Tok.LPAREN, "(")]
+        new_kids: list[UniNode] = [self.target]
+        is_gencompr = len(self.params) == 1 and isinstance(self.params[0], GenCompr)
+        if not is_gencompr:
+            new_kids.append(self.gen_token(Tok.LPAREN))
         for i, prm in enumerate(self.params):
             new_kids.append(prm)
             if i < len(self.params) - 1:
@@ -3720,7 +3729,8 @@ class FuncCall(Expr):
         if self.genai_call:
             new_kids.append(self.gen_token(Tok.KW_BY))
             new_kids.append(self.genai_call)
-        new_kids.append(self.gen_token(Tok.RPAREN, ")"))
+        if not is_gencompr:
+            new_kids.append(self.gen_token(Tok.RPAREN, ")"))
         self.set_kids(nodes=new_kids)
         return res
 

jaclang/lib.py

@@ -0,0 +1,17 @@
+"""Jac Library - User-friendly interface for library mode."""
+
+from jaclang.runtimelib.machine import JacMachineInterface
+
+# Automatically expose all public attributes from JacMachineInterface
+# This includes archetype classes (Obj, Node, Edge, Walker, Root, Path) and all methods
+_jac_interface_attrs = {
+    name: getattr(JacMachineInterface, name)
+    for name in dir(JacMachineInterface)
+    if not name.startswith("_")
+}
+
+# Add to module globals
+globals().update(_jac_interface_attrs)
+
+# Build __all__ with all JacMachineInterface exports
+__all__ = sorted(_jac_interface_attrs.keys())

jaclang/runtimelib/archetype.py

@@ -69,13 +69,13 @@ class AnchorReport:
     context: dict[str, Any]
 
 
-DataSpatialFilter: TypeAlias = (
+ObjectSpatialFilter: TypeAlias = (
     Callable[["Archetype"], bool] | "Archetype" | list["Archetype"] | None
 )
 
 
 @dataclass(eq=False, repr=False)
-class DataSpatialDestination:
+class ObjectSpatialDestination:
     """Object-Spatial Destination."""
 
     direction: EdgeDir
@@ -92,18 +92,18 @@ class DataSpatialDestination:
 
 
 @dataclass(eq=False, repr=False)
-class DataSpatialPath:
+class ObjectSpatialPath:
     """Object-Spatial Path."""
 
     origin: list[NodeArchetype]
-    destinations: list[DataSpatialDestination]
+    destinations: list[ObjectSpatialDestination]
     edge_only: bool
     from_visit: bool
 
     def __init__(
         self,
         origin: NodeArchetype | list[NodeArchetype],
-        destinations: list[DataSpatialDestination] | None = None,
+        destinations: list[ObjectSpatialDestination] | None = None,
     ) -> None:
         """Override Init."""
         if not isinstance(origin, list):
@@ -115,7 +115,7 @@ class DataSpatialPath:
 
     def convert(
         self,
-        filter: DataSpatialFilter,
+        filter: ObjectSpatialFilter,
     ) -> Callable[["Archetype"], bool] | None:
         """Convert filter."""
         if not filter:
@@ -129,44 +129,44 @@ class DataSpatialPath:
     def append(
         self,
         direction: EdgeDir,
-        edge: DataSpatialFilter,
-        node: DataSpatialFilter,
-    ) -> DataSpatialPath:
+        edge: ObjectSpatialFilter,
+        node: ObjectSpatialFilter,
+    ) -> ObjectSpatialPath:
         """Append destination."""
         self.destinations.append(
-            DataSpatialDestination(direction, self.convert(edge), self.convert(node))
+            ObjectSpatialDestination(direction, self.convert(edge), self.convert(node))
         )
         return self
 
-    def _out(
-        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
-    ) -> DataSpatialPath:
+    def edge_out(
+        self, edge: ObjectSpatialFilter = None, node: ObjectSpatialFilter = None
+    ) -> ObjectSpatialPath:
         """Override greater than function."""
         return self.append(EdgeDir.OUT, edge, node)
 
-    def _in(
-        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
-    ) -> DataSpatialPath:
+    def edge_in(
+        self, edge: ObjectSpatialFilter = None, node: ObjectSpatialFilter = None
+    ) -> ObjectSpatialPath:
         """Override greater than function."""
         return self.append(EdgeDir.IN, edge, node)
 
-    def _any(
-        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
-    ) -> DataSpatialPath:
+    def edge_any(
+        self, edge: ObjectSpatialFilter = None, node: ObjectSpatialFilter = None
+    ) -> ObjectSpatialPath:
         """Override greater than function."""
         return self.append(EdgeDir.ANY, edge, node)
 
-    def edge(self) -> DataSpatialPath:
+    def edge(self) -> ObjectSpatialPath:
         """Set edge only."""
         self.edge_only = True
         return self
 
-    def visit(self) -> DataSpatialPath:
+    def visit(self) -> ObjectSpatialPath:
         """Set from visit."""
         self.from_visit = True
         return self
 
-    def repr_builder(self, repr: str, dest: DataSpatialDestination, mark: str) -> str:
+    def repr_builder(self, repr: str, dest: ObjectSpatialDestination, mark: str) -> str:
         """Repr builder."""
         repr += mark
         repr += f' (edge{" filter" if dest.edge else ""}) '
@@ -361,8 +361,8 @@ class ObjectAnchor(Anchor):
 class Archetype:
     """Archetype Protocol."""
 
-    _jac_entry_funcs_: ClassVar[list[DataSpatialFunction]] = []
-    _jac_exit_funcs_: ClassVar[list[DataSpatialFunction]] = []
+    _jac_entry_funcs_: ClassVar[list[ObjectSpatialFunction]] = []
+    _jac_exit_funcs_: ClassVar[list[ObjectSpatialFunction]] = []
 
     @cached_property
     def __jac__(self) -> Anchor:
@@ -454,7 +454,7 @@ class Root(NodeArchetype):
 
 
 @dataclass(eq=False)
-class DataSpatialFunction:
+class ObjectSpatialFunction:
     """Object-Spatial Function."""
 
     name: str

jaclang/runtimelib/constructs.py

@@ -7,12 +7,12 @@ from .archetype import (
     AccessLevel,
     Anchor,
     Archetype,
-    DataSpatialFunction,
     EdgeAnchor,
     EdgeArchetype,
     GenericEdge,
     NodeAnchor,
     NodeArchetype,
+    ObjectSpatialFunction,
     Root,
     WalkerAnchor,
     WalkerArchetype,
@@ -32,7 +32,7 @@ __all__ = [
     "WalkerArchetype",
     "GenericEdge",
     "Root",
-    "DataSpatialFunction",
+    "ObjectSpatialFunction",
     "Memory",
     "ShelfStorage",
     "JacTestResult",

jaclang/runtimelib/machine.py

@@ -34,10 +34,10 @@ from uuid import UUID
 from jaclang.compiler.constant import Constants as Con, EdgeDir, colors
 from jaclang.compiler.program import JacProgram
 from jaclang.runtimelib.archetype import (
-    DataSpatialDestination,
-    DataSpatialFunction,
-    DataSpatialPath,
     GenericEdge as _GenericEdge,
+    ObjectSpatialDestination,
+    ObjectSpatialFunction,
+    ObjectSpatialPath,
     Root as _Root,
 )
 from jaclang.runtimelib.constructs import (
@@ -267,7 +267,7 @@ class JacNode:
 
     @staticmethod
     def get_edges(
-        origin: list[NodeArchetype], destination: DataSpatialDestination
+        origin: list[NodeArchetype], destination: ObjectSpatialDestination
     ) -> list[EdgeArchetype]:
         """Get edges connected to this node."""
         edges: OrderedDict[EdgeAnchor, EdgeArchetype] = OrderedDict()
@@ -300,7 +300,7 @@ class JacNode:
     @staticmethod
     def get_edges_with_node(
         origin: list[NodeArchetype],
-        destination: DataSpatialDestination,
+        destination: ObjectSpatialDestination,
         from_visit: bool = False,
     ) -> list[EdgeArchetype | NodeArchetype]:
         """Get edges connected to this node and the node."""
@@ -337,7 +337,7 @@ class JacNode:
 
     @staticmethod
     def edges_to_nodes(
-        origin: list[NodeArchetype], destination: DataSpatialDestination
+        origin: list[NodeArchetype], destination: ObjectSpatialDestination
     ) -> list[NodeArchetype]:
         """Get set of nodes connected to this node."""
         nodes: OrderedDict[NodeAnchor, NodeArchetype] = OrderedDict()
@@ -424,36 +424,6 @@ class JacWalker:
         else:
             raise TypeError("Invalid walker object")
 
-    @staticmethod
-    def ignore(
-        walker: WalkerArchetype,
-        expr: (
-            list[NodeArchetype | EdgeArchetype]
-            | list[NodeArchetype]
-            | list[EdgeArchetype]
-            | NodeArchetype
-            | EdgeArchetype
-        ),
-    ) -> bool:  # noqa: ANN401
-        """Jac's ignore stmt feature."""
-        if isinstance(walker, WalkerArchetype):
-            wanch = walker.__jac__
-            before_len = len(wanch.ignores)
-            for anchor in (
-                (i.__jac__ for i in expr) if isinstance(expr, list) else [expr.__jac__]
-            ):
-                if anchor not in wanch.ignores:
-                    if isinstance(anchor, NodeAnchor):
-                        wanch.ignores.append(anchor)
-                    elif isinstance(anchor, EdgeAnchor):
-                        if target := anchor.target:
-                            wanch.ignores.append(target)
-                        else:
-                            raise ValueError("Edge has no target.")
-            return len(wanch.ignores) > before_len
-        else:
-            raise TypeError("Invalid walker object")
-
     @staticmethod
     def spawn_call(
         walker: WalkerAnchor,
@@ -718,7 +688,7 @@ class JacClassReferences:
 
     TYPE_CHECKING: bool = TYPE_CHECKING
     EdgeDir: TypeAlias = EdgeDir
-    DSFunc: TypeAlias = DataSpatialFunction
+    DSFunc: TypeAlias = ObjectSpatialFunction
 
     Obj: TypeAlias = Archetype
     Node: TypeAlias = NodeArchetype
@@ -728,7 +698,7 @@ class JacClassReferences:
     Root: TypeAlias = _Root
     GenericEdge: TypeAlias = _GenericEdge
 
-    Path: TypeAlias = DataSpatialPath
+    Path: TypeAlias = ObjectSpatialPath
 
 
 class JacBuiltin:
@@ -1102,17 +1072,18 @@ class JacBasics:
         if custom:
             ctx.custom = expr
         else:
+            print(expr)
             ctx.reports.append(expr)
 
     @staticmethod
     def refs(
-        path: DataSpatialPath | NodeArchetype | list[NodeArchetype],
+        path: ObjectSpatialPath | NodeArchetype | list[NodeArchetype],
     ) -> (
         list[NodeArchetype] | list[EdgeArchetype] | list[NodeArchetype | EdgeArchetype]
     ):
         """Jac's apply_dir stmt feature."""
-        if not isinstance(path, DataSpatialPath):
-            path = DataSpatialPath(path, [DataSpatialDestination(EdgeDir.OUT)])
+        if not isinstance(path, ObjectSpatialPath):
+            path = ObjectSpatialPath(path, [ObjectSpatialDestination(EdgeDir.OUT)])
 
         origin = path.origin
 
@@ -1134,13 +1105,13 @@ class JacBasics:
 
     @staticmethod
     async def arefs(
-        path: DataSpatialPath | NodeArchetype | list[NodeArchetype],
+        path: ObjectSpatialPath | NodeArchetype | list[NodeArchetype],
     ) -> None:
         """Jac's apply_dir stmt feature."""
         pass
 
     @staticmethod
-    def filter(
+    def filter_on(
         items: list[Archetype],
         func: Callable[[Archetype], bool],
     ) -> list[Archetype]:
@@ -1226,7 +1197,7 @@ class JacBasics:
         return disconnect_occurred
 
     @staticmethod
-    def assign(target: list[T], attr_val: tuple[tuple[str], tuple[Any]]) -> list[T]:
+    def assign_all(target: list[T], attr_val: tuple[tuple[str], tuple[Any]]) -> list[T]:
         """Jac's assign comprehension feature."""
         for obj in target:
             attrs, values = attr_val
@@ -1328,17 +1299,26 @@ class JacBasics:
                 JacMachineInterface.get_context().mem.remove(anchor.id)
 
     @staticmethod
-    def entry(func: Callable) -> Callable:
+    def on_entry(func: Callable) -> Callable:
         """Mark a method as jac entry with this decorator."""
         setattr(func, "__jac_entry", None)  # noqa:B010
         return func
 
     @staticmethod
-    def exit(func: Callable) -> Callable:
+    def on_exit(func: Callable) -> Callable:
         """Mark a method as jac exit with this decorator."""
         setattr(func, "__jac_exit", None)  # noqa:B010
         return func
 
+
+class JacByLLM:
+    """Jac byLLM integration."""
+
+    @staticmethod
+    def get_mtir(caller: Callable, args: dict, call_params: dict) -> object:
+        """Get byLLM library."""
+        return None
+
     @staticmethod
     def sem(semstr: str, inner_semstr: dict[str, str]) -> Callable:
         """Attach the semstring to the given object."""
@@ -1352,11 +1332,39 @@ class JacBasics:
 
     @staticmethod
     def call_llm(model: object, mtir: object) -> Any:  # noqa: ANN401
-        """Call the LLM model."""
+        """Call the LLM model.
+
+        Note: This is for future uses of the feature in contexts that cannot be decorated.
+        For most use cases, use the `by` decorator instead.
+        """
         raise ImportError(
             "byLLM is not installed. Please install it with `pip install byllm` and run `jac clean`."
         )
 
+    @staticmethod
+    def by(model: object) -> Callable:
+        """Python library mode decorator for Jac's by llm() syntax."""
+
+        def _decorator(caller: Callable) -> Callable:
+            def _wrapped_caller(*args: object, **kwargs: object) -> object:
+                invoke_args: dict[int | str, object] = {}
+                for i, arg in enumerate(args):
+                    invoke_args[i] = arg
+                for key, value in kwargs.items():
+                    invoke_args[key] = value
+                mtir = JacMachine.get_mtir(
+                    caller=caller,
+                    args=invoke_args,
+                    call_params=(
+                        model.call_params if hasattr(model, "call_params") else {}
+                    ),
+                )
+                return JacMachine.call_llm(model, mtir)
+
+            return _wrapped_caller
+
+        return _decorator
+
 
 class JacUtils:
     """Jac Machine Utilities."""
@@ -1573,6 +1581,7 @@ class JacMachineInterface(
     JacBuiltin,
     JacCmd,
     JacBasics,
+    JacByLLM,
     JacUtils,
 ):
     """Jac Feature."""
@@ -1716,4 +1725,5 @@ class JacMachine(JacMachineInterface):
         JacMachine.base_path_dir = os.getcwd()
         JacMachine.program = JacProgram()
         JacMachine.pool = ThreadPoolExecutor()
+        JacMachine.exec_ctx.mem.close()
         JacMachine.exec_ctx = ExecutionContext()

jaclang/settings.py

@@ -14,13 +14,12 @@ class Settings:
     filter_sym_builtins: bool = True
     ast_symbol_info_detailed: bool = False
     pass_timer: bool = False
-    collect_py_dep_debug: bool = False
     print_py_raised_ast: bool = False
 
     # Compiler configuration
-    disable_mtllm: bool = False
     ignore_test_annex: bool = False
     pyout_jaclib_alias: str = "_jl"
+    library_mode: bool = False
     pyfile_raise: bool = False
     pyfile_raise_full: bool = False
 

jaclang/tests/fixtures/attr_pattern_case.jac

@@ -0,0 +1,18 @@
+obj A {
+    has b: B;
+}
+obj B {
+    has c: str;
+}
+
+
+with entry {
+    expr = "Hello Jaseci!";
+    a = A(B(expr));
+    match expr {
+        case a.b.c:
+            print("Matched a.b.c", a.b.c);
+        case _:
+            print("No match");
+    }
+}

jaclang/tests/fixtures/funccall_genexpr.jac

@@ -0,0 +1,7 @@
+def total(values: Any) {
+    return sum(values);
+}
+with entry {
+    result = total((x * x) for x in range(5));
+    print(f"Result: {result}");
+}

jaclang/tests/fixtures/funccall_genexpr.py

@@ -0,0 +1,5 @@
+def total(values):
+    return sum(values)
+
+result = total((x * x) for x in range(5))
+print(result)