jaclang 0.5.18__py3-none-any.whl → 0.6.1__py3-none-any.whl

jaclang/core/shelve_storage.py

@@ -0,0 +1,55 @@
+"""Shelve storage for persistence storage of jaclang runtime object."""
+
+import shelve
+from uuid import UUID
+
+from jaclang.core.construct import Architype
+from jaclang.core.memory import Memory
+
+
+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

jaclang/core/utils.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import ast as ast3
-from typing import Callable, TYPE_CHECKING
+import sys
+from contextlib import contextmanager
+from typing import Callable, Iterator, TYPE_CHECKING
 
 import jaclang.compiler.absyntree as ast
 from jaclang.core.registry import SemScope
@@ -12,6 +14,19 @@ if TYPE_CHECKING:
     from jaclang.core.construct import NodeAnchor, NodeArchitype
 
 
+@contextmanager
+def sys_path_context(path: str) -> Iterator[None]:
+    """Add a path to sys.path temporarily."""
+    novel_path = path not in sys.path
+    try:
+        if novel_path:
+            sys.path.append(path)
+        yield
+    finally:
+        if novel_path:
+            sys.path.remove(path)
+
+
 def collect_node_connections(
     current_node: NodeAnchor,
     visited_nodes: set,

jaclang/plugin/__init__.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from .default import hookimpl
-from .spec import Architype, DSFunc
+from .default import Architype, DSFunc, hookimpl
 
 __all__ = ["Architype", "DSFunc", "hookimpl"]

jaclang/plugin/builtin.py

@@ -20,9 +20,9 @@ def dotgen(
     dot_file: Optional[str] = None,
 ) -> str:
     """Print the dot graph."""
-    from jaclang.core.construct import root
     from jaclang.plugin.feature import pm
 
+    root = pm.hook.get_root()
     node = node if node is not None else root
     depth = depth if depth is not None else -1
     traverse = traverse if traverse is not None else False

jaclang/plugin/default.py

@@ -7,9 +7,11 @@ import html
 import os
 import pickle
 import types
+from contextvars import ContextVar
 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
@@ -19,7 +21,6 @@ from jaclang.core.aott import (
     get_all_type_explanations,
     get_info_types,
     get_object_string,
-    get_reasoning_output,
     get_type_annotation,
 )
 from jaclang.core.construct import (
@@ -35,10 +36,11 @@ from jaclang.core.construct import (
     Root,
     WalkerAnchor,
     WalkerArchitype,
-    root,
 )
 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
@@ -56,11 +58,10 @@ __all__ = [
     "WalkerAnchor",
     "NodeArchitype",
     "EdgeArchitype",
+    "Root",
     "WalkerArchitype",
     "Architype",
     "DSFunc",
-    "root",
-    "Root",
     "jac_importer",
     "T",
 ]
@@ -69,11 +70,95 @@ __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."""
 
     pm = pluggy.PluginManager("jac")
 
+    @staticmethod
+    @hookimpl
+    def context(session: str = "") -> ExecutionContext:
+        """Get the execution context."""
+        ctx = ExecContext.get()
+        if ctx is None:
+            ctx = ExecutionContext()
+            ExecContext.set(ctx)
+        return ctx
+
+    @staticmethod
+    @hookimpl
+    def reset_context() -> None:
+        """Reset the execution context."""
+        ctx = ExecContext.get()
+        if ctx:
+            ctx.reset()
+        ExecContext.set(None)
+
+    @staticmethod
+    @hookimpl
+    def memory_hook() -> Memory | None:
+        """Return the memory hook."""
+        return Jac.context().mem
+
     @staticmethod
     @hookimpl
     def make_architype(
@@ -378,6 +463,12 @@ class JacFeatureDefaults:
                 conn_edge = edge_spec()
                 edges.append(conn_edge)
                 i._jac_.connect_node(j, conn_edge)
+
+                if i._jac_.persistent or j._jac_.persistent:
+                    conn_edge.save()
+                    j.save()
+                    i.save()
+
         return right if not edges_only else edges
 
     @staticmethod
@@ -428,9 +519,15 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    def get_root() -> Architype:
+    def get_root() -> Root:
         """Jac's assign comprehension feature."""
-        return root
+        return Jac.context().get_root()
+
+    @staticmethod
+    @hookimpl
+    def get_root_type() -> Type[Root]:
+        """Jac's root getter."""
+        return Root
 
     @staticmethod
     @hookimpl
@@ -587,11 +684,18 @@ class JacFeatureDefaults:
         _scope = SemScope.get_scope_from_str(scope)
         assert _scope is not None
 
-        reason = False
-        if "reason" in model_params:
-            reason = model_params.pop("reason")
+        method = model_params.pop("method") if "method" in model_params else "Normal"
+        available_methods = model.MTLLM_METHOD_PROMPTS.keys()
+        assert (
+            method in available_methods
+        ), f"Invalid method: {method}. Select from {available_methods}"
+
+        context = (
+            "\n".join(model_params.pop("context")) if "context" in model_params else ""
+        )
 
         type_collector: list = []
+        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 = []
@@ -605,22 +709,34 @@ class JacFeatureDefaults:
 
         output_information = f"{outputs[0]} ({outputs[1]})"
         type_collector.extend(extract_non_primary_type(outputs[1]))
+        output_type_explanations = "\n".join(
+            list(
+                get_all_type_explanations(
+                    extract_non_primary_type(outputs[1]), mod_registry
+                ).values()
+            )
+        )
 
         type_explanations_list = list(
             get_all_type_explanations(type_collector, mod_registry).values()
         )
         type_explanations = "\n".join(type_explanations_list)
 
-        meaning_in = aott_raise(
-            information,
-            inputs_information,
-            output_information,
-            type_explanations,
-            action,
-            reason,
+        meaning_out = aott_raise(
+            model=model,
+            information=information,
+            inputs_information=inputs_information,
+            output_information=output_information,
+            type_explanations=type_explanations,
+            action=action,
+            context=context,
+            method=method,
+            tools=[],
+            model_params=model_params,
+        )
+        output = model.resolve_output(
+            meaning_out, outputs[0], outputs[1], output_type_explanations
         )
-        meaning_out = model.__infer__(meaning_in, **model_params)
-        reasoning, output = get_reasoning_output(meaning_out)
         return output
 
 

jaclang/plugin/feature.py

@@ -3,18 +3,22 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, TypeAlias, Union
+from typing import Any, Callable, Optional, TYPE_CHECKING, Type, Union
 
 from jaclang.compiler.absyntree import Module
-from jaclang.core.construct import (
-    Architype,
-    EdgeArchitype,
-    NodeArchitype,
-    Root,
-    WalkerArchitype,
-)
 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
 
@@ -28,10 +32,23 @@ class JacFeature:
     """Jac Feature."""
 
     import abc
-    from jaclang.plugin.spec import DSFunc
     from jaclang.compiler.constant import EdgeDir
+    from jaclang.plugin.spec import DSFunc
+
+    @staticmethod
+    def context(session: str = "") -> ExecutionContext:
+        """Create execution context."""
+        return pm.hook.context(session=session)
+
+    @staticmethod
+    def reset_context() -> None:
+        """Reset execution context."""
+        return pm.hook.reset_context()
 
-    RootType: TypeAlias = Root
+    @staticmethod
+    def memory_hook() -> Memory | None:
+        """Create memory abstraction."""
+        return pm.hook.memory_hook()
 
     @staticmethod
     def make_architype(
@@ -82,7 +99,7 @@ class JacFeature:
         mdl_alias: Optional[str] = None,
         override_name: Optional[str] = None,
         mod_bundle: Optional[Module] = None,
-        lng: Optional[str] = None,
+        lng: Optional[str] = "jac",
         items: Optional[dict[str, Union[str, bool]]] = None,
     ) -> Optional[types.ModuleType]:
         """Core Import Process."""
@@ -218,10 +235,15 @@ class JacFeature:
         return pm.hook.assign_compr(target=target, attr_val=attr_val)
 
     @staticmethod
-    def get_root() -> Architype:
-        """Jac's assign comprehension feature."""
+    def get_root() -> Root:
+        """Jac's root getter."""
         return pm.hook.get_root()
 
+    @staticmethod
+    def get_root_type() -> Type[Root]:
+        """Jac's root type getter."""
+        return pm.hook.get_root_type()
+
     @staticmethod
     def build_edge(
         is_undirected: bool,

jaclang/plugin/spec.py

@@ -3,17 +3,21 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, TypeVar, Union
+from dataclasses import dataclass
+from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
 
 from jaclang.compiler.absyntree import Module
-from jaclang.plugin.default import (
-    Architype,
-    DSFunc,
-    EdgeArchitype,
-    EdgeDir,
-    NodeArchitype,
-    WalkerArchitype,
-)
+
+if TYPE_CHECKING:
+    from jaclang.core.construct import EdgeArchitype, NodeArchitype
+    from jaclang.plugin.default import (
+        Architype,
+        EdgeDir,
+        ExecutionContext,
+        WalkerArchitype,
+        Root,
+    )
+    from jaclang.core.memory import Memory
 
 import pluggy
 
@@ -22,9 +26,41 @@ 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."""
 
+    @staticmethod
+    @hookspec(firstresult=True)
+    def context(session: str = "") -> ExecutionContext:
+        """Get the execution context."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def reset_context() -> None:
+        """Reset the execution context."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def memory_hook() -> Memory | None:
+        """Create memory abstraction."""
+        raise NotImplementedError
+
     @staticmethod
     @hookspec(firstresult=True)
     def make_architype(
@@ -198,7 +234,13 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def get_root() -> Architype:
+    def get_root() -> Root:
+        """Jac's root getter."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_root_type() -> Type[Root]:
         """Jac's root getter."""
         raise NotImplementedError