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

jaclang/core/aott.py

@@ -8,78 +8,40 @@ import re
 from enum import Enum
 from typing import Any
 
+from jaclang.core.llms.base import BaseLLM
 from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 
 
-PROMPT_TEMPLATE = """
-[System Prompt]
-This is an operation you must perform and return the output values. Neither, the methodology, extra sentences nor the code are not needed.
-Input/Type formatting: Explanation of the Input (variable_name) (type) = value
-
-[Information]
-{information}
-
-[Inputs Information]
-{inputs_information}
-
-[Output Information]
-{output_information}
-
-[Type Explanations]
-{type_explanations}
-
-[Action]
-{action}
-
-{reason_suffix}
-"""  # noqa E501
-
-WITH_REASON_SUFFIX = """
-Reason and return the output result(s) only, adhering to the provided Type in the following format
-
-[Reasoning] <Reason>
-[Output] <Result>
-"""
-
-WITHOUT_REASON_SUFFIX = """Generate and return the output result(s) only, adhering to the provided Type in the following format
-
-[Output] <result>
-"""  # noqa E501
-
-
 def aott_raise(
+    model: BaseLLM,
     information: str,
     inputs_information: str,
     output_information: str,
     type_explanations: str,
     action: str,
-    reason: bool,
+    context: str,
+    method: str,
+    tools: list["Tool"],
+    model_params: dict,
 ) -> str:
     """AOTT Raise uses the information (Meanings types values) provided to generate a prompt(meaning in)."""
-    return PROMPT_TEMPLATE.format(
-        information=information,
-        inputs_information=inputs_information,
-        output_information=output_information,
-        type_explanations=type_explanations,
-        action=action,
-        reason_suffix=WITH_REASON_SUFFIX if reason else WITHOUT_REASON_SUFFIX,
-    )
-
-
-def get_reasoning_output(s: str) -> tuple:
-    """Get the reasoning and output from the meaning out string."""
-    reasoning_match = re.search(r"\[Reasoning\](.*)\[Output\]", s)
-    output_match = re.search(r"\[Output\](.*)", s)
-
-    if reasoning_match and output_match:
-        reasoning = reasoning_match.group(1)
-        output = output_match.group(1)
-        return (reasoning.strip(), output.strip())
-    elif output_match:
-        output = output_match.group(1)
-        return (None, output.strip())
+    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}"
+        return model(meaning_in, **model_params)
     else:
-        return (None, None)
+        assert tools, "Tools must be provided for the ReAct method."
+        # TODO: Implement ReAct method
+        return ""
 
 
 def get_info_types(
@@ -176,22 +138,31 @@ def get_type_explanation(
         _, type_info = mod_registry.lookup(scope=sem_info_scope)
         type_info_str = []
         type_info_types = []
+        type_example = [f"{sem_info.name}("]
         if sem_info.type == "Enum" and isinstance(type_info, list):
             for enum_item in type_info:
                 type_info_str.append(
-                    f"{enum_item.semstr} (EnumItem) ({enum_item.name})"
+                    f"{enum_item.semstr} ({enum_item.name}) (EnumItem)"
                 )
+            type_example[0] = type_example[0].replace("(", f".{enum_item.name}")
         elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
             type_info, list
         ):
             for arch_item in type_info:
+                if arch_item.type in ["obj", "class", "node", "edge"]:
+                    continue
                 type_info_str.append(
-                    f"{arch_item.semstr} ({arch_item.type}) ({arch_item.name})"
+                    f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})"
                 )
+                type_example.append(f"{arch_item.name}={arch_item.type}, ")
                 if arch_item.type and extract_non_primary_type(arch_item.type):
                     type_info_types.extend(extract_non_primary_type(arch_item.type))
+            if len(type_example) > 1:
+                type_example[-1] = type_example[-1].replace(", ", ")")
+            else:
+                type_example.append(")")
         return (
-            f"{sem_info.semstr} ({sem_info.type}) ({sem_info.name}) = {', '.join(type_info_str)}",
+            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}",  # noqa: E501
             set(type_info_types),
         )
     return None, None
@@ -232,3 +203,12 @@ def get_type_annotation(data: Any) -> str:  # noqa: ANN401
             return "dict[str, Any]"
     else:
         return str(type(data).__name__)
+
+
+class Tool:
+    """Tool class for the AOTT operations."""
+
+    def __init__(self) -> None:
+        """Initialize the Tool class."""
+        # TODO: Implement the Tool class
+        pass

jaclang/core/construct.py

@@ -2,15 +2,15 @@
 
 from __future__ import annotations
 
-# import shelve
-import types
 import unittest
 from dataclasses import dataclass, field
-from typing import Any, Callable, Optional, Union
-
+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
 
 
 @dataclass(eq=False)
@@ -18,6 +18,7 @@ class ElementAnchor:
     """Element Anchor."""
 
     obj: Architype
+    id: UUID = field(default_factory=uuid4)
 
 
 @dataclass(eq=False)
@@ -35,6 +36,37 @@ class NodeAnchor(ObjectAnchor):
 
     obj: NodeArchitype
     edges: list[EdgeArchitype] = field(default_factory=lambda: [])
+    edge_ids: list[UUID] = field(default_factory=lambda: [])
+    persistent: bool = False
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state.pop("obj")
+        if self.edges and "edges" in state:
+            edges = state.pop("edges")
+            state["edge_ids"] = [e._jac_.id for e in edges]
+
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
+        if "edge_ids" in state:
+            self.edge_ids = state.pop("edge_ids")
+
+    def populate_edges(self) -> None:
+        """Populate edges from edge ids."""
+        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)
+                if edge is None:
+                    raise ValueError(f"Edge with id {e_id} not found.")
+                elif not isinstance(edge, EdgeArchitype):
+                    raise ValueError(f"Object with id {e_id} is not an edge.")
+                else:
+                    self.edges.append(edge)
+            self.edge_ids.clear()
 
     def connect_node(self, nd: NodeArchitype, edg: EdgeArchitype) -> NodeArchitype:
         """Connect a node with given edge."""
@@ -48,6 +80,8 @@ class NodeAnchor(ObjectAnchor):
         target_obj: Optional[list[NodeArchitype]],
     ) -> list[EdgeArchitype]:
         """Get edges connected to this node."""
+        self.populate_edges()
+
         edge_list: list[EdgeArchitype] = [*self.edges]
         ret_edges: list[EdgeArchitype] = []
         edge_list = filter_func(edge_list) if filter_func else edge_list
@@ -76,6 +110,9 @@ class NodeAnchor(ObjectAnchor):
         target_obj: Optional[list[NodeArchitype]],
     ) -> list[NodeArchitype]:
         """Get set of nodes connected to this node."""
+        self.populate_edges()
+        for edge in self.edges:
+            edge.populate_nodes()
         edge_list: list[EdgeArchitype] = [*self.edges]
         node_list: list[NodeArchitype] = []
         edge_list = filter_func(edge_list) if filter_func else edge_list
@@ -126,7 +163,29 @@ class EdgeAnchor(ObjectAnchor):
     obj: EdgeArchitype
     source: Optional[NodeArchitype] = None
     target: Optional[NodeArchitype] = None
+    source_id: Optional[UUID] = None
+    target_id: Optional[UUID] = None
     is_undirected: bool = False
+    persistent: bool = False
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state.pop("obj")
+
+        if self.source:
+            state["source_id"] = self.source._jac_.id
+            state.pop("source")
+
+        if self.target:
+            state["target_id"] = self.target._jac_.id
+            state.pop("target")
+
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
 
     def attach(
         self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
@@ -268,26 +327,113 @@ class Architype:
         """Create default architype."""
         self._jac_: ObjectAnchor = ObjectAnchor(obj=self)
 
+    def __hash__(self) -> int:
+        """Override hash for architype."""
+        return hash(self._jac_.id)
+
+    def __eq__(self, other: object) -> bool:
+        """Override equality for architype."""
+        if not isinstance(other, Architype):
+            return False
+        else:
+            return self._jac_.id == other._jac_.id
+
+    def __repr__(self) -> str:
+        """Override repr for architype."""
+        return f"{self.__class__.__name__}"
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        raise NotImplementedError
+
 
 class NodeArchitype(Architype):
     """Node Architype Protocol."""
 
+    _jac_: NodeAnchor
+
     def __init__(self) -> None:
         """Create node architype."""
         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."""
+        self._jac_.persistent = True
+        Jac.context().save_obj(self, persistent=True)
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state["_jac_"] = self._jac_.__getstate__()
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
+        self._jac_ = NodeAnchor(obj=self)
+        self._jac_.__setstate__(state["_jac_"])
 
 
 class EdgeArchitype(Architype):
     """Edge Architype Protocol."""
 
+    _jac_: EdgeAnchor
+    persistent: bool = False
+
     def __init__(self) -> None:
         """Create edge architype."""
         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."""
+        self.persistent = True
+        Jac.context().save_obj(self, persistent=True)
+
+    def __getstate__(self) -> dict:
+        """Override getstate for pickle and shelve."""
+        state = self.__dict__.copy()
+        state["_jac_"] = self._jac_.__getstate__()
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Override setstate for pickle and shelve."""
+        self.__dict__.update(state)
+        self._jac_ = EdgeAnchor(obj=self)
+        self._jac_.__setstate__(state["_jac_"])
+
+    def populate_nodes(self) -> None:
+        """Populate nodes for the edges from node ids."""
+        if self._jac_.source_id:
+            obj = Jac.context().get_obj(self._jac_.source_id)
+            if obj is None:
+                raise ValueError(f"Node with id {self._jac_.source_id} not found.")
+            elif not isinstance(obj, NodeArchitype):
+                raise ValueError(
+                    f"Object with id {self._jac_.source_id} is not a node."
+                )
+            else:
+                self._jac_.source = obj
+                self._jac_.source_id = None
+        if self._jac_.target_id:
+            obj = Jac.context().get_obj(self._jac_.target_id)
+            if obj is None:
+                raise ValueError(f"Node with id {self._jac_.target_id} not found.")
+            elif not isinstance(obj, NodeArchitype):
+                raise ValueError(
+                    f"Object with id {self._jac_.target_id} is not a node."
+                )
+            else:
+                self._jac_.target = obj
+                self._jac_.target_id = None
 
 
 class WalkerArchitype(Architype):
     """Walker Architype Protocol."""
 
+    _jac_: WalkerAnchor
+
     def __init__(self) -> None:
         """Create walker architype."""
         self._jac_: WalkerAnchor = WalkerAnchor(obj=self)
@@ -301,6 +447,12 @@ class Root(NodeArchitype):
     reachable_nodes: list[NodeArchitype] = []
     connections: set[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]] = set()
 
+    def __init__(self) -> None:
+        """Create root node."""
+        super().__init__()
+        self._jac_.id = UUID(int=0)
+        self._jac_.persistent = True
+
     def reset(self) -> None:
         """Reset the root."""
         self.reachable_nodes = []
@@ -315,19 +467,6 @@ class GenericEdge(EdgeArchitype):
     _jac_exit_funcs_ = []
 
 
-@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 JacTestResult(unittest.TextTestResult):
     """Jac test result class."""
 
@@ -407,9 +546,6 @@ class JacTestCheck:
         """Create a new test."""
         JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
 
-    def __getattr__(self, name: str) -> Union[bool, Any]:
+    def __getattr__(self, name: str) -> object:
         """Make convenient check.Equal(...) etc."""
         return getattr(JacTestCheck.test_case, name)
-
-
-root = Root()

jaclang/core/importer.py

@@ -10,6 +10,7 @@ from typing import Optional, Union
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
+from jaclang.core.utils import sys_path_context
 from jaclang.utils.log import logging
 
 
@@ -21,56 +22,41 @@ def jac_importer(
     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."""
-    dir_path, file_name = (
-        path.split(path.join(*(target.split("."))) + ".py")
-        if lng == "py"
-        else path.split(path.join(*(target.split("."))) + ".jac")
+    dir_path, file_name = path.split(
+        path.join(*(target.split("."))) + (".jac" if lng == "jac" else ".py")
     )
     module_name = path.splitext(file_name)[0]
     package_path = dir_path.replace(path.sep, ".")
 
-    if package_path and f"{package_path}.{module_name}" in sys.modules and lng != "py":
+    if (
+        not override_name
+        and package_path
+        and f"{package_path}.{module_name}" in sys.modules
+    ):
         return sys.modules[f"{package_path}.{module_name}"]
-    elif not package_path and module_name in sys.modules and lng != "py":
+    elif not override_name and not package_path and module_name in sys.modules:
         return sys.modules[module_name]
 
-    caller_dir = path.dirname(base_path) if not path.isdir(base_path) else base_path
-    if not caller_dir:
-        caller_dir = getcwd()
-    chomp_target = target
-    if chomp_target.startswith("."):
-        chomp_target = chomp_target[1:]
-        while chomp_target.startswith("."):
-            caller_dir = path.dirname(caller_dir)
-            chomp_target = chomp_target[1:]
-    caller_dir = path.join(caller_dir, dir_path)
-
+    caller_dir = get_caller_dir(target, base_path, dir_path)
     full_target = path.normpath(path.join(caller_dir, file_name))
-    path_added = False
-    if caller_dir not in sys.path:
-        sys.path.append(caller_dir)
-        path_added = True
 
-    module_name = override_name if override_name else module_name
-    module = types.ModuleType(module_name)
-    module.__file__ = full_target
-    module.__name__ = module_name
-    module.__dict__["__jac_mod_bundle__"] = mod_bundle
-    if lng != "py":
+    if lng == "py":
+        module = py_import(
+            target=target, items=items, absorb=absorb, mdl_alias=mdl_alias
+        )
+    else:
+        module_name = override_name if override_name else module_name
+        module = create_jac_py_module(
+            mod_bundle, module_name, package_path, full_target
+        )
         if mod_bundle:
-            codeobj = (
-                mod_bundle.gen.py_bytecode
-                if full_target == mod_bundle.loc.mod_path
-                else mod_bundle.mod_deps[full_target].gen.py_bytecode
-            )
-            if isinstance(codeobj, bytes):
-                codeobj = marshal.loads(codeobj)
+            codeobj = mod_bundle.mod_deps[full_target].gen.py_bytecode
+            codeobj = marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
         else:
-
             gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
             pyc_file_path = path.join(gen_dir, module_name + ".jbc")
             if (
@@ -89,46 +75,60 @@ def jac_importer(
                     return None
                 else:
                     codeobj = marshal.loads(result.ir.gen.py_bytecode)
-
-        if package_path:
-            parts = package_path.split(".")
-            for i in range(len(parts)):
-                package_name = ".".join(parts[: i + 1])
-                if package_name not in sys.modules:
-                    sys.modules[package_name] = types.ModuleType(package_name)
-
-            setattr(sys.modules[package_path], module_name, module)
-            sys.modules[f"{package_path}.{module_name}"] = module
-        sys.modules[module_name] = module
-
         if not codeobj:
             raise ImportError(f"No bytecode found for {full_target}")
-        exec(codeobj, module.__dict__)
+        with sys_path_context(caller_dir):
+            exec(codeobj, module.__dict__)
 
-    (
-        py_import(target=target, items=items, absorb=absorb, mdl_alias=mdl_alias)
-        if lng == "py" or lng == "jac"
-        else None
-    )
+    return module
 
-    if path_added:
-        sys.path.remove(caller_dir)
 
+def create_jac_py_module(
+    mod_bundle: Optional[Module], module_name: str, package_path: str, full_target: str
+) -> types.ModuleType:
+    """Create a module."""
+    module = types.ModuleType(module_name)
+    module.__file__ = full_target
+    module.__name__ = module_name
+    module.__dict__["__jac_mod_bundle__"] = mod_bundle
+    if package_path:
+        parts = package_path.split(".")
+        for i in range(len(parts)):
+            package_name = ".".join(parts[: i + 1])
+            if package_name not in sys.modules:
+                sys.modules[package_name] = types.ModuleType(package_name)
+
+        setattr(sys.modules[package_path], module_name, module)
+        sys.modules[f"{package_path}.{module_name}"] = module
+    sys.modules[module_name] = module
     return module
 
 
+def get_caller_dir(target: str, base_path: str, dir_path: str) -> str:
+    """Get the directory of the caller."""
+    caller_dir = base_path if path.isdir(base_path) else path.dirname(base_path)
+    caller_dir = caller_dir if caller_dir else getcwd()
+    chomp_target = target
+    if chomp_target.startswith("."):
+        chomp_target = chomp_target[1:]
+        while chomp_target.startswith("."):
+            caller_dir = path.dirname(caller_dir)
+            chomp_target = chomp_target[1:]
+    caller_dir = path.join(caller_dir, dir_path)
+    return caller_dir
+
+
 def py_import(
     target: str,
     items: Optional[dict[str, Union[str, bool]]] = None,
     absorb: bool = False,
     mdl_alias: Optional[str] = None,
-) -> None:
+) -> types.ModuleType:
     """Import a Python module."""
     try:
         target = target.lstrip(".") if target.startswith("..") else target
-        imported_module = importlib.import_module(target)
+        imported_module = importlib.import_module(name=target)
         main_module = __import__("__main__")
-        # importer = importlib.import_module(caller)
         if absorb:
             for name in dir(imported_module):
                 if not name.startswith("_"):
@@ -136,11 +136,21 @@ def py_import(
 
         elif items:
             for name, alias in items.items():
-                setattr(
-                    main_module,
-                    alias if isinstance(alias, str) else name,
-                    getattr(imported_module, name),
-                )
+                try:
+                    setattr(
+                        main_module,
+                        alias if isinstance(alias, str) else name,
+                        getattr(imported_module, name),
+                    )
+                except AttributeError as e:
+                    if hasattr(imported_module, "__path__"):
+                        setattr(
+                            main_module,
+                            alias if isinstance(alias, str) else name,
+                            importlib.import_module(f"{target}.{name}"),
+                        )
+                    else:
+                        raise e
 
         else:
             setattr(
@@ -148,5 +158,7 @@ def py_import(
                 mdl_alias if isinstance(mdl_alias, str) else target,
                 imported_module,
             )
-    except ImportError:
+        return imported_module
+    except ImportError as e:
         print(f"Failed to import module {target}")
+        raise e

jaclang/core/llms/__init__.py

@@ -0,0 +1,20 @@
+"""LLM implementations for MTLLM."""
+
+from .anthropic import Anthropic
+from .base import BaseLLM
+from .groq import Groq
+from .huggingface import Huggingface
+from .ollama import Ollama
+from .openai import OpenAI
+from .togetherai import TogetherAI
+
+
+__all__ = [
+    "Anthropic",
+    "Ollama",
+    "Huggingface",
+    "Groq",
+    "BaseLLM",
+    "OpenAI",
+    "TogetherAI",
+]