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

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -127,7 +127,6 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             is_imported=False,
             kid=valid,
         )
-        ret.gen.py_ast = [node]
         return self.nu(ret)
 
     def proc_function_def(
@@ -209,6 +208,8 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         kid = ([doc] if doc else []) + (
             [name, sig, valid_body] if sig else [name, valid_body]
         )
+        if not sig:
+            raise self.ice("Function signature not found")
         ret = ast.Ability(
             name_ref=name,
             is_async=False,

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -1,4 +1,9 @@
-"""Jac to python ast link pass."""
+"""Jac to python ast link pass.
+
+This pass is needed so cases where there are multiple Jac nodes relevant to a
+single python node can be linked. For example FuncDef doesn't have a Name node
+however Ability does.
+"""
 
 import ast as ast3
 

jaclang/compiler/passes/main/pyout_pass.py

@@ -35,7 +35,9 @@ class PyOutPass(Pass):
                 f"Unable to find module {node.loc.mod_path} or no code present.", node
             )
             return
-        mods = [node] + self.get_all_sub_nodes(node, ast.Module)
+        mods = [node] + [
+            i for i in self.get_all_sub_nodes(node, ast.Module) if not i.stub_only
+        ]
         for mod in mods:
             mod_path, out_path_py, out_path_pyc = self.get_output_targets(mod)
             if os.path.exists(out_path_pyc) and os.path.getmtime(

jaclang/compiler/passes/main/schedules.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from .sub_node_tab_pass import SubNodeTabPass  # noqa: I100
 from .import_pass import JacImportPass, PyImportPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
-from .def_impl_match_pass import DeclDefMatchPass  # noqa: I100
+from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
@@ -25,7 +25,7 @@ py_code_gen = [
     JacImportPass,
     PyImportPass,
     SymTabBuildPass,
-    DeclDefMatchPass,
+    DeclImplMatchPass,
     DefUsePass,
     RegistryPass,
     PyastGenPass,
@@ -33,5 +33,6 @@ py_code_gen = [
     PyBytecodeGenPass,
 ]
 
-py_code_gen_typed = [*py_code_gen, JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
+type_checker_sched = [JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
+py_code_gen_typed = [*py_code_gen, *type_checker_sched]
 py_compiler = [*py_code_gen, PyOutPass]

jaclang/compiler/passes/main/tests/fixtures/incautoimpl.jac

@@ -0,0 +1,7 @@
+include:jac autoimpl;
+
+with entry {
+    foo();
+    bar();
+    baz();
+}

jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py

@@ -1,11 +1,11 @@
 """Test pass module."""
 
 from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import DeclDefMatchPass
+from jaclang.compiler.passes.main import DeclImplMatchPass
 from jaclang.utils.test import TestCase
 
 
-class DeclDefMatchPassTests(TestCase):
+class DeclImplMatchPassTests(TestCase):
     """Test pass module."""
 
     def setUp(self) -> None:
@@ -14,7 +14,7 @@ class DeclDefMatchPassTests(TestCase):
 
     def test_ability_connected_to_decl(self) -> None:
         """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclDefMatchPass)
+        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclImplMatchPass)
         self.assertFalse(state.errors_had)
         self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
         self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.body)
@@ -23,7 +23,7 @@ class DeclDefMatchPassTests(TestCase):
 
     def test_ability_connected_to_decl_post(self) -> None:
         """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base2.jac"), DeclDefMatchPass)
+        state = jac_file_to_pass(self.fixture_abs_path("base2.jac"), DeclImplMatchPass)
         self.assertFalse(state.errors_had)
         self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
         self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.body)

jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -28,3 +28,24 @@ class ImportPassPassTests(TestCase):
         self.assertIn("getme.impl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
         self.assertIn("autoimpl.something.else.impl", mod_names)
+
+    def test_import_include_auto_impl(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("incautoimpl.jac"), JacImportPass
+        )
+        num_modules = len(state.ir.get_all_sub_nodes(ast.Module))
+        mod_names = [i.name for i in state.ir.get_all_sub_nodes(ast.Module)]
+        self.assertEqual(num_modules, 4)
+        self.assertIn("getme.impl", mod_names)
+        self.assertIn("autoimpl", mod_names)
+        self.assertIn("autoimpl.impl", mod_names)
+        self.assertIn("autoimpl.something.else.impl", mod_names)
+
+    def test_annexalbe_by_discovery(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("incautoimpl.jac"), JacImportPass
+        )
+        for i in state.ir.get_all_sub_nodes(ast.Module):
+            self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))

jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -59,6 +59,6 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertIn("HasVar - species - Type: builtins.str", out)
         self.assertIn("myDog - Type: type_info.Dog", out)
         self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 27)
+        self.assertEqual(out.count("Type: builtins.str"), 28)
         for i in lis:
             self.assertNotIn(i, out)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -421,7 +421,10 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.emit_ln(node, i.gen.jac)
             if isinstance(i, ast.Token) and i.name == Tok.KW_BY:
-                self.emit(node, f"{i.gen.jac} ")
+                if not node.params:
+                    self.emit(node, f"{i.gen.jac} ")
+                else:
+                    self.emit(node, f" {i.gen.jac} ")
             else:
                 if (
                     line_break_needed
@@ -2402,7 +2405,16 @@ class JacFormatPass(Pass):
             and isinstance(node.parent.parent, ast.FString)
         ):
             self.emit(node, node.value)
-        self.emit(node, node.value)
+        if "\n" in node.value:
+            string_type = node.value[0:3]
+            pure_string = node.value[3:-3]
+            lines = pure_string.split("\n")
+            self.emit(node, string_type)
+            for line in lines[:-1]:
+                self.emit_ln(node, line)
+            self.emit_ln(node, f"{lines[-1]}{string_type}")
+        else:
+            self.emit(node, node.value)
 
     def enter_bool(self, node: ast.Bool) -> None:
         """Sub objects.

jaclang/compiler/passes/tool/tests/fixtures/doc_string.jac

@@ -0,0 +1,15 @@
+class foo {
+    """
+    doc string
+    """
+    can print_here() {
+        print("i'm here");
+    }
+
+    """this is a
+    multiline docstring
+    to test"""
+    can also_print() {
+        print("I'm in also");
+    }
+}

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -44,8 +44,8 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
             if diff:
                 print(f"Differences found in comparison:\n{diff}")
-                # raise AssertionError("Files differ after formatting.")
-                self.skipTest("Test failed, but skipping instead of failing.")
+                raise AssertionError("Files differ after formatting.")
+
         except FileNotFoundError:
             print(f"File not found: {original_file} or {formatted_file}")
             raise
@@ -76,6 +76,9 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         self.compare_files(
             os.path.join(self.fixture_abs_path(""), "corelib_fmt.jac"),
         )
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "doc_string.jac"),
+        )
 
     def test_compare_myca_fixtures(self) -> None:
         """Tests if files in the myca fixtures directory do not change after being formatted."""
@@ -135,14 +138,13 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             diff = "\n".join(unified_diff(before.splitlines(), after.splitlines()))
             self.assertFalse(diff, "AST structures differ after formatting.")
 
-        except Exception:
+        except Exception as e:
             print(add_line_numbers(code_gen_pure.ir.source.code))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print(add_line_numbers(code_gen_format.ir.gen.jac))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
-            self.skipTest("Test failed, but skipping instead of failing.")
-            # raise e
+            raise e
 
 
 JacFormatPassTests.self_attach_micro_tests()

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -30,7 +30,7 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
             self.assertEqual(x, y)
         except Exception as e:
             print("\n".join(unified_diff(x.splitlines(), y.splitlines())))
-            self.skipTest(f"Test failed, but skipping instead of failing: {e}")
+            raise e
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
@@ -75,7 +75,6 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
         except Exception as e:
             raise e
-            # self.skipTest(f"Test failed, but skipping instead of failing: {e}")
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/compiler/symtable.py

@@ -17,7 +17,7 @@ class SymbolType(Enum):
 
     MODULE = "module"  # LSP: Module
     MOD_VAR = "mod_var"  # LSP: Variable
-    VAR = "var"  # LSP: Variable
+    VAR = "variable"  # LSP: Variable
     IMM_VAR = "immutable"  # LSP: Constant
     ABILITY = "ability"  # LSP: Function
     OBJECT_ARCH = "object"  # LSP: Class
@@ -54,6 +54,12 @@ class SymbolInfo:
         self.acc_tag: Optional[SymbolAccess] = acc_tag
         self.typ_sym_table: Optional[SymbolTable] = None
 
+    @property
+    def clean_type(self) -> str:
+        """Get clean type."""
+        ret_type = self.typ.replace("builtins.", "").replace("NoType", "")
+        return ret_type
+
 
 class SymbolAccess(Enum):
     """Symbol types."""
@@ -101,6 +107,20 @@ class Symbol:
         """Get sym_type."""
         return self.decl.sym_type
 
+    @property
+    def sym_path_str(self) -> str:
+        """Return a full path of the symbol."""
+        out = [self.defn[0].sym_name]
+        current_tab = self.parent_tab
+        while current_tab is not None:
+            out.append(current_tab.name)
+            if current_tab.has_parent():
+                current_tab = current_tab.parent
+            else:
+                break
+        out.reverse()
+        return ".".join(out)
+
     def add_defn(self, node: ast.AstSymbolNode) -> None:
         """Add defn."""
         self.defn.append(node)

jaclang/core/aott.py

@@ -4,18 +4,30 @@ AOTT: Automated Operational Type Transformation.
 This has all the necessary functions to perform the AOTT operations.
 """
 
+import base64
+import logging
 import re
 from enum import Enum
+from io import BytesIO
 from typing import Any
 
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
 from jaclang.core.llms.base import BaseLLM
 from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 
 
+IMG_FORMATS = ["PngImageFile", "JpegImageFile"]
+
+
 def aott_raise(
     model: BaseLLM,
     information: str,
-    inputs_information: str,
+    inputs_information: str | list[dict],
     output_information: str,
     type_explanations: str,
     action: str,
@@ -25,18 +37,43 @@ def aott_raise(
     model_params: dict,
 ) -> str:
     """AOTT Raise uses the information (Meanings types values) provided to generate a prompt(meaning in)."""
+    system_prompt = model.MTLLM_SYSTEM_PROMPT
+    meaning_in: str | list[dict]
     if method != "ReAct":
-        system_prompt = model.MTLLM_SYSTEM_PROMPT
-        mtllm_prompt = model.MTLLM_PROMPT.format(
-            information=information,
-            inputs_information=inputs_information,
-            output_information=output_information,
-            type_explanations=type_explanations,
-            action=action,
-            context=context,
-        )
         method_prompt = model.MTLLM_METHOD_PROMPTS[method]
-        meaning_in = f"{system_prompt}\n{mtllm_prompt}\n{method_prompt}"
+        if isinstance(inputs_information, str):
+            mtllm_prompt = model.MTLLM_PROMPT.format(
+                information=information,
+                inputs_information=inputs_information,
+                output_information=output_information,
+                type_explanations=type_explanations,
+                action=action,
+                context=context,
+            ).strip()
+            meaning_in = f"{system_prompt}\n{mtllm_prompt}\n{method_prompt}".strip()
+        else:
+            upper_half = model.MTLLM_PROMPT.split("{inputs_information}")[0]
+            lower_half = model.MTLLM_PROMPT.split("{inputs_information}")[1]
+            upper_half = upper_half.format(
+                information=information,
+                context=context,
+            )
+            lower_half = lower_half.format(
+                output_information=output_information,
+                type_explanations=type_explanations,
+                action=action,
+            )
+            meaning_in = (
+                [
+                    {"type": "text", "text": system_prompt},
+                    {"type": "text", "text": upper_half},
+                ]
+                + inputs_information
+                + [
+                    {"type": "text", "text": lower_half},
+                    {"type": "text", "text": method_prompt},
+                ]
+            )
         return model(meaning_in, **model_params)
     else:
         assert tools, "Tools must be provided for the ReAct method."
@@ -212,3 +249,62 @@ class Tool:
         """Initialize the Tool class."""
         # TODO: Implement the Tool class
         pass
+
+
+def get_input_information(
+    inputs: list[tuple[str, str, str, Any]], type_collector: list
+) -> str | list[dict]:
+    """
+    Get the input information for the AOTT operation.
+
+    Returns:
+        str | list[dict]: If the input does not contain images, returns a string with the input information.
+            If the input contains images, returns a list of dictionaries representing the input information,
+            where each dictionary contains either text or image_url.
+
+    """
+    contains_imgs = any(get_type_annotation(i[3]) in IMG_FORMATS for i in inputs)
+    if not contains_imgs:
+        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])}"
+            )
+        return "\n".join(inputs_information_list)
+    else:
+        inputs_information_dict_list: list[dict] = []
+        for i in inputs:
+            if get_type_annotation(i[3]) in IMG_FORMATS:
+                img_base64 = image_to_base64(i[3])
+                image_repr: list[dict] = [
+                    {
+                        "type": "text",
+                        "text": f"{i[0]} ({i[2]}) (Image) = ",
+                    },
+                    {"type": "image_url", "image_url": {"url": img_base64}},
+                ]
+                inputs_information_dict_list.extend(image_repr)
+                continue
+            typ_anno = get_type_annotation(i[3])
+            type_collector.extend(extract_non_primary_type(typ_anno))
+            inputs_information_dict_list.append(
+                {
+                    "type": "text",
+                    "text": f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}",
+                }
+            )
+        return inputs_information_dict_list
+
+
+def image_to_base64(image: Image) -> str:
+    """Convert an image to base64 expected by OpenAI."""
+    if not Image:
+        log = logging.getLogger(__name__)
+        log.error("Pillow is not installed. Please install Pillow to use images.")
+        return ""
+    img_format = image.format
+    with BytesIO() as buffer:
+        image.save(buffer, format=img_format, quality=100)
+        return f"data:image/{img_format.lower()};base64,{base64.b64encode(buffer.getvalue()).decode()}"

jaclang/core/construct.py

@@ -2,14 +2,15 @@
 
 from __future__ import annotations
 
+import shelve
 import unittest
+from contextvars import ContextVar
 from dataclasses import dataclass, field
 from typing import Callable, Optional
 from uuid import UUID, uuid4
 
 from jaclang.compiler.constant import EdgeDir
 from jaclang.core.utils import collect_node_connections
-from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import DSFunc
 
 
@@ -57,6 +58,8 @@ class NodeAnchor(ObjectAnchor):
 
     def populate_edges(self) -> None:
         """Populate edges from edge ids."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         if len(self.edges) == 0 and len(self.edge_ids) > 0:
             for e_id in self.edge_ids:
                 edge = Jac.context().get_obj(e_id)
@@ -354,11 +357,15 @@ class NodeArchitype(Architype):
 
     def __init__(self) -> None:
         """Create node architype."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self._jac_: NodeAnchor = NodeAnchor(obj=self)
         Jac.context().save_obj(self, persistent=self._jac_.persistent)
 
     def save(self) -> None:
         """Save the node to the memory/storage hierarchy."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self._jac_.persistent = True
         Jac.context().save_obj(self, persistent=True)
 
@@ -383,11 +390,15 @@ class EdgeArchitype(Architype):
 
     def __init__(self) -> None:
         """Create edge architype."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self._jac_: EdgeAnchor = EdgeAnchor(obj=self)
         Jac.context().save_obj(self, persistent=self.persistent)
 
     def save(self) -> None:
         """Save the edge to the memory/storage hierarchy."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self.persistent = True
         Jac.context().save_obj(self, persistent=True)
 
@@ -405,6 +416,8 @@ class EdgeArchitype(Architype):
 
     def populate_nodes(self) -> None:
         """Populate nodes for the edges from node ids."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         if self._jac_.source_id:
             obj = Jac.context().get_obj(self._jac_.source_id)
             if obj is None:
@@ -439,6 +452,13 @@ class WalkerArchitype(Architype):
         self._jac_: WalkerAnchor = WalkerAnchor(obj=self)
 
 
+class GenericEdge(EdgeArchitype):
+    """Generic Root Node."""
+
+    _jac_entry_funcs_ = []
+    _jac_exit_funcs_ = []
+
+
 class Root(NodeArchitype):
     """Generic Root Node."""
 
@@ -460,11 +480,157 @@ class Root(NodeArchitype):
         self._jac_.edges = []
 
 
-class GenericEdge(EdgeArchitype):
-    """Generic Root Node."""
+class Memory:
+    """Memory module interface."""
 
-    _jac_entry_funcs_ = []
-    _jac_exit_funcs_ = []
+    mem: dict[UUID, Architype] = {}
+    save_obj_list: dict[UUID, Architype] = {}
+
+    def __init__(self) -> None:
+        """init."""
+        pass
+
+    def get_obj(self, obj_id: UUID) -> Architype | None:
+        """Get object from memory."""
+        return self.get_obj_from_store(obj_id)
+
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
+        """Get object from the underlying store."""
+        ret = self.mem.get(obj_id)
+        return ret
+
+    def has_obj(self, obj_id: UUID) -> bool:
+        """Check if the object exists."""
+        return self.has_obj_in_store(obj_id)
+
+    def has_obj_in_store(self, obj_id: UUID) -> bool:
+        """Check if the object exists in the underlying store."""
+        return obj_id in self.mem
+
+    def save_obj(self, item: Architype, persistent: bool) -> None:
+        """Save object."""
+        self.mem[item._jac_.id] = item
+        if persistent:
+            # TODO: check if it needs to be saved, i.e. dirty or not
+            self.save_obj_list[item._jac_.id] = item
+
+    def commit(self) -> None:
+        """Commit changes to persistent storage, if applicable."""
+        pass
+
+    def close(self) -> None:
+        """Close any connection, if applicable."""
+        self.mem.clear()
+
+
+class ShelveStorage(Memory):
+    """Shelve storage for jaclang runtime object."""
+
+    storage: shelve.Shelf | None = None
+
+    def __init__(self, session: str = "") -> None:
+        """Init shelve storage."""
+        super().__init__()
+        if session:
+            self.connect(session)
+
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
+        """Get object from the underlying store."""
+        obj = super().get_obj_from_store(obj_id)
+        if obj is None and self.storage:
+            obj = self.storage.get(str(obj_id))
+            if obj is not None:
+                self.mem[obj_id] = obj
+
+        return obj
+
+    def has_obj_in_store(self, obj_id: UUID | str) -> bool:
+        """Check if the object exists in the underlying store."""
+        return obj_id in self.mem or (
+            str(obj_id) in self.storage if self.storage else False
+        )
+
+    def commit(self) -> None:
+        """Commit changes to persistent storage."""
+        if self.storage is not None:
+            for obj_id, obj in self.save_obj_list.items():
+                self.storage[str(obj_id)] = obj
+        self.save_obj_list.clear()
+
+    def connect(self, session: str) -> None:
+        """Connect to storage."""
+        self.session = session
+        self.storage = shelve.open(session)
+
+    def close(self) -> None:
+        """Close the storage."""
+        super().close()
+        self.commit()
+        if self.storage:
+            self.storage.close()
+        self.storage = None
+
+
+class ExecutionContext:
+    """Default Execution Context implementation."""
+
+    mem: Optional[Memory]
+    root: Optional[Root]
+
+    def __init__(self) -> None:
+        """Create execution context."""
+        super().__init__()
+        self.mem = ShelveStorage()
+        self.root = None
+
+    def init_memory(self, session: str = "") -> None:
+        """Initialize memory."""
+        if session:
+            self.mem = ShelveStorage(session)
+        else:
+            self.mem = Memory()
+
+    def get_root(self) -> Root:
+        """Get the root object."""
+        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
+
+
+exec_context: ContextVar[ExecutionContext | None] = ContextVar(
+    "ExecutionContext", default=None
+)
 
 
 class JacTestResult(unittest.TextTestResult):