jaclang 0.5.17__py3-none-any.whl → 0.6.0__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(
@@ -179,19 +141,19 @@ def get_type_explanation(
         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)"
                 )
         elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
             type_info, list
         ):
             for arch_item in type_info:
                 type_info_str.append(
-                    f"{arch_item.semstr} ({arch_item.type}) ({arch_item.name})"
+                    f"{arch_item.semstr} ({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))
         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}) = {', '.join(type_info_str)}",
             set(type_info_types),
         )
     return None, None
@@ -232,3 +194,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/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,37 @@ 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 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 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 +71,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 +132,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 +154,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",
+]

jaclang/core/llms/anthropic.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 Anthropic(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 anthropic  # type: ignore
+
+        self.client = anthropic.Anthropic()
+        self.verbose = verbose
+        self.max_tries = max_tries
+        self.model_name = kwargs.get("model_name", "claude-3-sonnet-20240229")
+        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.messages.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.content[0].text

jaclang/core/llms/base.py

@@ -0,0 +1,206 @@
+"""Base Large Language Model (LLM) class."""
+
+import logging
+import re
+
+from .utils import logger
+
+
+httpx_logger = logging.getLogger("httpx")
+httpx_logger.setLevel(logging.WARNING)
+
+SYSTEM_PROMPT = """
+[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
+"""  # noqa E501
+
+
+PROMPT_TEMPLATE = """
+[Information]
+{information}
+
+[Context]
+{context}
+
+[Inputs Information]
+{inputs_information}
+
+[Output Information]
+{output_information}
+
+[Type Explanations]
+{type_explanations}
+
+[Action]
+{action}
+"""  # noqa E501
+
+NORMAL_SUFFIX = """Generate and return the output result(s) only, adhering to the provided Type in the following format
+
+[Output] <result>
+"""  # noqa E501
+
+REASON_SUFFIX = """
+Reason and return the output result(s) only, adhering to the provided Type in the following format
+
+[Reasoning] <Reason>
+[Output] <Result>
+"""
+
+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
+
+MTLLM_OUTPUT_FIX_PROMPT = """
+[Output]
+{model_output}
+
+[Previous Result You Provided]
+{previous_output}
+
+[Desired Output Type]
+{output_info}
+
+[Type Explanations]
+{output_type_info}
+
+Above output is not in the desired Output Format/Type. Please provide the output in the desired type. Do not repeat the previously provided output.
+Important: Do not provide the code or the methodology. Only provide
+the output in the desired format.
+"""  # noqa E501
+
+OUTPUT_CHECK_PROMPT = """
+[Output]
+{model_output}
+
+[Desired Output Type]
+{output_type}
+
+[Type Explanations]
+{output_type_info}
+
+Check if the output is exactly in the desired Output Type. Important: Just say 'Yes' or 'No'.
+"""  # noqa E501
+
+
+class BaseLLM:
+    """Base Large Language Model (LLM) class."""
+
+    MTLLM_SYSTEM_PROMPT: str = SYSTEM_PROMPT
+    MTLLM_PROMPT: str = PROMPT_TEMPLATE
+    MTLLM_METHOD_PROMPTS: dict[str, str] = {
+        "Normal": NORMAL_SUFFIX,
+        "Reason": REASON_SUFFIX,
+        "Chain-of-Thoughts": CHAIN_OF_THOUGHT_SUFFIX,
+        "ReAct": REACT_SUFFIX,
+    }
+    OUTPUT_FIX_PROMPT: str = MTLLM_OUTPUT_FIX_PROMPT
+    OUTPUT_CHECK_PROMPT: str = OUTPUT_CHECK_PROMPT
+
+    def __init__(
+        self, verbose: bool = False, max_tries: int = 10, **kwargs: dict
+    ) -> None:
+        """Initialize the Large Language Model (LLM) client."""
+        self.verbose = verbose
+        self.max_tries = max_tries
+        raise NotImplementedError
+
+    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+        """Infer a response from the input meaning."""
+        raise NotImplementedError
+
+    def __call__(self, input_text: str, **kwargs: dict) -> str:
+        """Infer a response from the input text."""
+        if self.verbose:
+            logger.info(f"Meaning In\n{input_text}")
+        return self.__infer__(input_text, **kwargs)
+
+    def resolve_output(
+        self,
+        meaning_out: str,
+        output_semstr: str,
+        output_type: str,
+        output_type_info: str,
+    ) -> str:
+        """Resolve the output string to return the reasoning and output."""
+        if self.verbose:
+            logger.opt(colors=True).info(f"Meaning Out\n<green>{meaning_out}</green>")
+        output_match = re.search(r"\[Output\](.*)", meaning_out)
+        output = output_match.group(1).strip() if output_match else None
+        if not output_match:
+            output = self._extract_output(
+                meaning_out,
+                output_semstr,
+                output_type,
+                output_type_info,
+                self.max_tries,
+            )
+        return str(output)
+
+    def _check_output(
+        self, output: str, output_type: str, output_type_info: str
+    ) -> bool:
+        """Check if the output is in the desired format."""
+        output_check_prompt = self.OUTPUT_CHECK_PROMPT.format(
+            model_output=output,
+            output_type=output_type,
+            output_type_info=output_type_info,
+        )
+        llm_output = self.__infer__(output_check_prompt)
+        return "yes" in llm_output.lower()
+
+    def _extract_output(
+        self,
+        meaning_out: str,
+        output_semstr: str,
+        output_type: str,
+        output_type_info: str,
+        max_tries: int,
+        previous_output: str = "None",
+    ) -> str:
+        """Extract the output from the meaning out string."""
+        if max_tries == 0:
+            logger.error("Failed to extract output. Max tries reached.")
+            raise ValueError(
+                "Failed to extract output. Try Changing the Semstrings, provide examples or change the method."
+            )
+
+        if self.verbose:
+            if max_tries < self.max_tries:
+                logger.info(
+                    f"Failed to extract output. Trying to extract output again. Max tries left: {max_tries}"
+                )
+            else:
+                logger.info("Extracting output from the meaning out string.")
+
+        output_fix_prompt = self.OUTPUT_FIX_PROMPT.format(
+            model_output=meaning_out,
+            previous_output=previous_output,
+            output_info=f"{output_semstr} ({output_type})",
+            output_type_info=output_type_info,
+        )
+        llm_output = self.__infer__(output_fix_prompt)
+        is_in_desired_format = self._check_output(
+            llm_output, output_type, output_type_info
+        )
+        if self.verbose:
+            logger.info(
+                f"Extracted Output: {llm_output}. Is in Desired Format: {is_in_desired_format}"
+            )
+        if is_in_desired_format:
+            return llm_output
+        return self._extract_output(
+            meaning_out,
+            output_semstr,
+            output_type,
+            output_type_info,
+            max_tries - 1,
+            llm_output,
+        )

jaclang/core/llms/groq.py

@@ -0,0 +1,67 @@
+"""Groq 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 Groq(BaseLLM):
+    """Groq 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 Groq API client."""
+        import groq  # type: ignore
+
+        self.client = groq.Groq()
+        self.verbose = verbose
+        self.max_tries = max_tries
+        self.model_name = kwargs.get("model_name", "mixtral-8x7b-32768")
+        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}]
+        model_params = {
+            k: v
+            for k, v in kwargs.items()
+            if k not in ["model_name", "temperature", "max_tokens"]
+        }
+        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,
+            **model_params,
+        )
+        return output.choices[0].message.content