jaclang 0.5.17__py3-none-any.whl → 0.6.0__py3-none-any.whl

jaclang/core/llms/huggingface.py

@@ -0,0 +1,73 @@
+"""Huggingface client for MTLLM."""
+
+from .base import BaseLLM
+
+
+REASON_SUFFIX = """
+Reason and return the output results(s) only such that <Output> should be eval(<Output>) Compatible and reflects the
+expected output type, Follow the format below to provide the reasoning for the output result(s).
+
+[Reasoning] <Reasoning>
+[Output] <Output>
+"""
+
+NORMAL_SUFFIX = """Return the output result(s) only such that <Output> should be eval(<Output>) Compatible and
+reflects the expected output type, Follow the format below to provide the output result(s).
+
+[Output] <Output>
+"""  # noqa E501
+
+CHAIN_OF_THOUGHT_SUFFIX = """
+Generate and return the output result(s) only, adhering to the provided Type in the following format. Perform the operation in a chain of thoughts.(Think Step by Step)
+
+[Chain of Thoughts] <Chain of Thoughts>
+[Output] <Result>
+"""  # noqa E501
+
+REACT_SUFFIX = """
+"""  # noqa E501
+
+
+class Huggingface(BaseLLM):
+    """Huggingface API client for Large Language Models (LLMs)."""
+
+    MTLLM_METHOD_PROMPTS: dict[str, str] = {
+        "Normal": NORMAL_SUFFIX,
+        "Reason": REASON_SUFFIX,
+        "Chain-of-Thoughts": CHAIN_OF_THOUGHT_SUFFIX,
+        "ReAct": REACT_SUFFIX,
+    }
+
+    def __init__(
+        self, verbose: bool = False, max_tries: int = 10, **kwargs: dict
+    ) -> None:
+        """Initialize the Huggingface API client."""
+        import torch  # type: ignore
+        from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline  # type: ignore
+
+        torch.random.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            kwargs.get("model_name", "microsoft/Phi-3-mini-128k-instruct"),
+            device_map=kwargs.get("device_map", "cuda"),
+            torch_dtype="auto",
+            trust_remote_code=True,
+        )
+        tokenizer = AutoTokenizer.from_pretrained(
+            kwargs.get("model_name", "microsoft/Phi-3-mini-128k-instruct")
+        )
+        self.verbose = verbose
+        self.max_tries = max_tries
+        self.pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+        self.temperature = kwargs.get("temperature", 0.7)
+        self.max_tokens = kwargs.get("max_new_tokens", 1024)
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.pipe(
+            messages,
+            temperature=kwargs.get("temperature", self.temperature),
+            max_length=kwargs.get("max_new_tokens", self.max_tokens),
+            **kwargs,
+        )
+        return output[0]["generated_text"][-1]["content"]

jaclang/core/llms/ollama.py

@@ -0,0 +1,78 @@
+"""Ollama client for MTLLM."""
+
+from .base import BaseLLM
+
+REASON_SUFFIX = """
+Reason and return the output results(s) only such that <Output> should be eval(<Output>) Compatible and reflects the
+expected output type, Follow the format below to provide the reasoning for the output result(s).
+
+[Reasoning] <Reasoning>
+[Output] <Output>
+"""
+
+NORMAL_SUFFIX = """Return the output result(s) only such that <Output> should be eval(<Output>) Compatible and
+reflects the expected output type, Follow the format below to provide the output result(s).
+
+[Output] <Output>
+"""  # noqa E501
+
+CHAIN_OF_THOUGHT_SUFFIX = """
+Generate and return the output result(s) only, adhering to the provided Type in the following format. Perform the operation in a chain of thoughts.(Think Step by Step)
+
+[Chain of Thoughts] <Chain of Thoughts>
+[Output] <Result>
+"""  # noqa E501
+
+REACT_SUFFIX = """
+"""  # noqa E501
+
+
+class Ollama(BaseLLM):
+    """Ollama API client for Large Language Models (LLMs)."""
+
+    MTLLM_METHOD_PROMPTS: dict[str, str] = {
+        "Normal": NORMAL_SUFFIX,
+        "Reason": REASON_SUFFIX,
+        "Chain-of-Thoughts": CHAIN_OF_THOUGHT_SUFFIX,
+        "ReAct": REACT_SUFFIX,
+    }
+
+    def __init__(
+        self, verbose: bool = False, max_tries: int = 10, **kwargs: dict
+    ) -> None:
+        """Initialize the Ollama API client."""
+        import ollama  # type: ignore
+
+        self.client = ollama.Client(host=kwargs.get("host", "http://localhost:11434"))
+        self.verbose = verbose
+        self.max_tries = max_tries
+        self.model_name = kwargs.get("model_name", "phi3")
+        self.default_model_params = {
+            k: v for k, v in kwargs.items() if k not in ["model_name", "host"]
+        }
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        model = str(kwargs.get("model_name", self.model_name))
+        if not self.check_model(model):
+            self.download_model(model)
+        model_params = {k: v for k, v in kwargs.items() if k not in ["model_name"]}
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.client.chat(
+            model=model,
+            messages=messages,
+            options={**self.default_model_params, **model_params},
+        )
+        return output["message"]["content"]
+
+    def check_model(self, model_name: str) -> bool:
+        """Check if the model is available."""
+        try:
+            self.client.show(model_name)
+            return True
+        except Exception:
+            return False
+
+    def download_model(self, model_name: str) -> None:
+        """Download the model."""
+        self.client.pull(model_name)

jaclang/core/llms/openai.py

@@ -0,0 +1,61 @@
+"""Anthropic API client for MTLLM."""
+
+from .base import BaseLLM
+
+
+REASON_SUFFIX = """
+Reason and return the output result(s) only, adhering to the provided Type in the following format
+
+[Reasoning] <Reason>
+[Output] <Result>
+"""
+
+NORMAL_SUFFIX = """Generate and return the output result(s) only, adhering to the provided Type in the following format
+
+[Output] <result>
+"""  # noqa E501
+
+CHAIN_OF_THOUGHT_SUFFIX = """
+Generate and return the output result(s) only, adhering to the provided Type in the following format. Perform the operation in a chain of thoughts.(Think Step by Step)
+
+[Chain of Thoughts] <Chain of Thoughts>
+[Output] <Result>
+"""  # noqa E501
+
+REACT_SUFFIX = """
+"""  # noqa E501
+
+
+class OpenAI(BaseLLM):
+    """Anthropic API client for MTLLM."""
+
+    MTLLM_METHOD_PROMPTS: dict[str, str] = {
+        "Normal": NORMAL_SUFFIX,
+        "Reason": REASON_SUFFIX,
+        "Chain-of-Thoughts": CHAIN_OF_THOUGHT_SUFFIX,
+        "ReAct": REACT_SUFFIX,
+    }
+
+    def __init__(
+        self, verbose: bool = False, max_tries: int = 10, **kwargs: dict
+    ) -> None:
+        """Initialize the Anthropic API client."""
+        import openai  # type: ignore
+
+        self.client = openai.OpenAI()
+        self.verbose = verbose
+        self.max_tries = max_tries
+        self.model_name = kwargs.get("model_name", "gpt-3.5-turbo")
+        self.temperature = kwargs.get("temperature", 0.7)
+        self.max_tokens = kwargs.get("max_tokens", 1024)
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.client.chat.completions.create(
+            model=kwargs.get("model_name", self.model_name),
+            temperature=kwargs.get("temperature", self.temperature),
+            max_tokens=kwargs.get("max_tokens", self.max_tokens),
+            messages=messages,
+        )
+        return output.choices[0].message.content

jaclang/core/llms/togetherai.py

@@ -0,0 +1,60 @@
+"""Anthropic API client for MTLLM."""
+
+from .base import BaseLLM
+
+REASON_SUFFIX = """
+Reason and return the output result(s) only, adhering to the provided Type in the following format
+
+[Reasoning] <Reason>
+[Output] <Result>
+"""
+
+NORMAL_SUFFIX = """Generate and return the output result(s) only, adhering to the provided Type in the following format
+
+[Output] <result>
+"""  # noqa E501
+
+CHAIN_OF_THOUGHT_SUFFIX = """
+Generate and return the output result(s) only, adhering to the provided Type in the following format. Perform the operation in a chain of thoughts.(Think Step by Step)
+
+[Chain of Thoughts] <Chain of Thoughts>
+[Output] <Result>
+"""  # noqa E501
+
+REACT_SUFFIX = """
+"""  # noqa E501
+
+
+class TogetherAI(BaseLLM):
+    """Anthropic API client for MTLLM."""
+
+    MTLLM_METHOD_PROMPTS: dict[str, str] = {
+        "Normal": NORMAL_SUFFIX,
+        "Reason": REASON_SUFFIX,
+        "Chain-of-Thoughts": CHAIN_OF_THOUGHT_SUFFIX,
+        "ReAct": REACT_SUFFIX,
+    }
+
+    def __init__(
+        self, verbose: bool = False, max_tries: int = 10, **kwargs: dict
+    ) -> None:
+        """Initialize the Anthropic API client."""
+        import together  # type: ignore
+
+        self.client = together.Together()
+        self.verbose = verbose
+        self.max_tries = max_tries
+        self.model_name = kwargs.get("model_name", "mistralai/Mistral-7B-Instruct-v0.3")
+        self.temperature = kwargs.get("temperature", 0.7)
+        self.max_tokens = kwargs.get("max_tokens", 1024)
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        messages = [{"role": "user", "content": meaning_in}]
+        output = self.client.chat.completions.create(
+            model=kwargs.get("model_name", self.model_name),
+            temperature=kwargs.get("temperature", self.temperature),
+            max_tokens=kwargs.get("max_tokens", self.max_tokens),
+            messages=messages,
+        )
+        return output.choices[0].message.content

jaclang/core/llms/utils.py

@@ -0,0 +1,9 @@
+"""Utility functions for the LLMs module."""
+
+try:
+    from loguru import logger  # noqa F401
+except ImportError:
+    import logging
+
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)

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/default.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import fnmatch
+import html
 import os
 import pickle
 import types
@@ -18,7 +19,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 (
@@ -85,7 +85,11 @@ class JacFeatureDefaults:
         for i in on_entry + on_exit:
             i.resolve(cls)
         if not issubclass(cls, arch_base):
+            # Saving the module path and reassign it after creating cls
+            # So the jac modules are part of the correct module
+            cur_module = cls.__module__
             cls = type(cls.__name__, (cls, arch_base), {})
+            cls.__module__ = cur_module
             cls._jac_entry_funcs_ = on_entry  # type: ignore
             cls._jac_exit_funcs_ = on_exit  # type: ignore
         else:
@@ -423,10 +427,16 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    def get_root() -> Architype:
+    def get_root() -> Root:
         """Jac's assign comprehension feature."""
         return root
 
+    @staticmethod
+    @hookimpl
+    def get_root_type() -> Type[Root]:
+        """Jac's root getter."""
+        return Root
+
     @staticmethod
     @hookimpl
     def build_edge(
@@ -582,9 +592,15 @@ 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 = []
         information, collected_types = get_info_types(_scope, mod_registry, incl_info)
@@ -600,22 +616,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
 
 
@@ -691,13 +719,16 @@ class JacBuiltin:
         for source, target, edge in connections:
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{edge._jac_.obj.__class__.__name__} "];\n'
+                f' [label="{html.escape(str(edge._jac_.obj.__class__.__name__))} "];\n'
             )
         for node_ in visited_nodes:
             color = (
                 colors[node_depths[node_]] if node_depths[node_] < 25 else colors[24]
             )
-            dot_content += f'{visited_nodes.index(node_)} [label="{node_._jac_.obj}" fillcolor="{color}"];\n'
+            dot_content += (
+                f'{visited_nodes.index(node_)} [label="{html.escape(str(node_._jac_.obj))}"'
+                f'fillcolor="{color}"];\n'
+            )
         if dot_file:
             with open(dot_file, "w") as f:
                 f.write(dot_content + "}")

jaclang/plugin/feature.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, TypeAlias, Union
+from typing import Any, Callable, Optional, Type, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.core.construct import (
@@ -31,8 +31,6 @@ class JacFeature:
     from jaclang.plugin.spec import DSFunc
     from jaclang.compiler.constant import EdgeDir
 
-    RootType: TypeAlias = Root
-
     @staticmethod
     def make_architype(
         cls: type,
@@ -82,7 +80,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 +216,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

@@ -12,6 +12,7 @@ from jaclang.plugin.default import (
     EdgeArchitype,
     EdgeDir,
     NodeArchitype,
+    Root,
     WalkerArchitype,
 )
 
@@ -198,7 +199,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
 

jaclang/settings.py

@@ -0,0 +1,95 @@
+"""Main settings of Jac lang."""
+
+import configparser
+import os
+from dataclasses import dataclass, fields
+
+
+@dataclass
+class Settings:
+    """Main settings of Jac lang."""
+
+    fuse_type_info_debug: bool = False
+    py_raise: bool = False
+
+    def __post_init__(self) -> None:
+        """Initialize settings."""
+        home_dir = os.path.expanduser("~")
+        config_dir = os.path.join(home_dir, ".jaclang")
+        self.config_file_path = os.path.join(config_dir, "config.ini")
+        os.makedirs(config_dir, exist_ok=True)
+        if not os.path.exists(self.config_file_path):
+            with open(self.config_file_path, "w") as f:
+                f.write("[settings]\n")
+        self.load_all()
+
+    def load_all(self) -> None:
+        """Load settings from all available sources."""
+        self.load_config_file()
+        self.load_env_vars()
+
+    def load_config_file(self) -> None:
+        """Load settings from a configuration file."""
+        config_parser = configparser.ConfigParser()
+        config_parser.read(self.config_file_path)
+        if "settings" in config_parser:
+            for key in config_parser["settings"]:
+                if key in [f.name for f in fields(self)]:
+                    setattr(
+                        self, key, self.convert_type(config_parser["settings"][key])
+                    )
+
+    def load_env_vars(self) -> None:
+        """Override settings from environment variables if available."""
+        for key in [f.name for f in fields(self)]:
+            env_value = os.getenv("JACLANG_" + key.upper())
+            if env_value is not None:
+                setattr(self, key, self.convert_type(env_value))
+
+        # def load_command_line_arguments(self):
+        #     """Override settings from command-line arguments if provided."""
+        #     parser = argparse.ArgumentParser()
+        #     parser.add_argument(
+        #         "--debug",
+        #         type=self.str_to_bool,
+        #         nargs="?",
+        #         const=True,
+        #         default=self.config["debug"],
+        #     )
+        #     parser.add_argument("--port", type=int, default=self.config["port"])
+        #     parser.add_argument("--host", default=self.config["host"])
+        #     args = parser.parse_args()
+
+    def str_to_bool(self, value: str) -> bool:
+        """Convert string to boolean."""
+        return value.lower() in ("yes", "y", "true", "t", "1")
+
+    def convert_type(self, value: str) -> bool | str | int:
+        """Convert string values from the config to the appropriate type."""
+        if value.isdigit():
+            return int(value)
+        if value.lower() in (
+            "true",
+            "false",
+            "t",
+            "f",
+            "yes",
+            "no",
+            "y",
+            "n",
+            "1",
+            "0",
+        ):
+            return self.str_to_bool(value)
+        return value
+
+    def __str__(self) -> str:
+        """Return string representation of the settings."""
+        return "\n".join(
+            [f"{field.name}: {getattr(self, field.name)}" for field in fields(self)]
+        )
+
+
+settings = Settings()
+
+__all__ = ["settings"]

jaclang/utils/helpers.py

@@ -131,7 +131,6 @@ def import_target_to_relative_path(
     import_level: int,
     import_target: str,
     base_path: Optional[str] = None,
-    file_extension: str = ".jac",
 ) -> str:
     """Convert an import target string into a relative file path."""
     if not base_path:
@@ -141,7 +140,12 @@ def import_target_to_relative_path(
     actual_parts = parts[traversal_levels:]
     for _ in range(traversal_levels):
         base_path = os.path.dirname(base_path)
-    relative_path = os.path.join(base_path, *actual_parts) + file_extension
+    relative_path = os.path.join(base_path, *actual_parts)
+    relative_path = (
+        relative_path + ".jac"
+        if os.path.exists(relative_path + ".jac")
+        else relative_path
+    )
     return relative_path
 
 

jaclang/utils/treeprinter.py

@@ -88,16 +88,19 @@ def print_ast_tree(
     from jaclang.compiler.absyntree import AstSymbolNode, Token
 
     def __node_repr_in_tree(node: AstNode) -> str:
+        access = (
+            f"Access: {node.access.tag.value}"
+            if isinstance(node, ast.AstAccessNode) and node.access is not None
+            else ""
+        )
         if isinstance(node, Token) and isinstance(node, AstSymbolNode):
-            return (
-                f"{node.__class__.__name__} - {node.value} - Type: {node.sym_info.typ}"
-            )
+            return f"{node.__class__.__name__} - {node.value} - Type: {node.sym_info.typ}, {access}"
         elif isinstance(node, Token):
-            return f"{node.__class__.__name__} - {node.value}"
+            return f"{node.__class__.__name__} - {node.value}, {access}"
         elif isinstance(node, AstSymbolNode):
-            return f"{node.__class__.__name__} - {node.sym_name} - Type: {node.sym_info.typ}"
+            return f"{node.__class__.__name__} - {node.sym_name} - Type: {node.sym_info.typ}, {access}"
         else:
-            return f"{node.__class__.__name__}"
+            return f"{node.__class__.__name__}, {access}"
 
     def __node_repr_in_py_tree(node: ast3.AST) -> str:
         if isinstance(node, ast3.Constant):

jaclang/vendor/mypy/checker.py

@@ -3637,11 +3637,10 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
                 if (
                     lv.node.final_unset_in_class
                     and not lv.node.final_set_in_init
-                    and not self.is_stub
-                    and  # It is OK to skip initializer in stub files.
+                    and not self.is_stub  # It is OK to skip initializer in stub files.
                     # Avoid extra error messages, if there is no type in Final[...],
                     # then we already reported the error about missing r.h.s.
-                    isinstance(s, AssignmentStmt)
+                    and isinstance(s, AssignmentStmt)
                     and s.type is not None
                 ):
                     self.msg.final_without_value(s)