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

jaclang/core/llms/anthropic.py

@@ -1,90 +0,0 @@
-"""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 = str(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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        if not isinstance(meaning_in, str):
-            assert self.model_name.startswith(
-                ("claude-3-opus", "claude-3-sonnet", "claude-3-haiku")
-            ), f"Model {self.model_name} is not multimodal, use a multimodal model instead."
-
-            import re
-
-            formatted_meaning_in = []
-            for item in meaning_in:
-                if item["type"] == "image_url":
-                    # "data:image/jpeg;base64,base64_string"
-                    img_match = re.match(
-                        r"data:(image/[a-zA-Z]*);base64,(.*)", item["source"]
-                    )
-                    if img_match:
-                        media_type, base64_string = img_match.groups()
-                    formatted_meaning_in.append(
-                        {
-                            "type": "image",
-                            "source": {
-                                "type": "base64",
-                                "media_type": media_type,
-                                "data": base64_string,
-                            },
-                        }
-                    )
-                    continue
-                formatted_meaning_in.append(item)
-            meaning_in = formatted_meaning_in
-        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

@@ -1,206 +0,0 @@
-"""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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        raise NotImplementedError
-
-    def __call__(self, input_text: str | list[dict], **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.info(f"Meaning Out\n{meaning_out}")
-        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

@@ -1,70 +0,0 @@
-"""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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        assert isinstance(
-            meaning_in, str
-        ), "Currently Multimodal models are not supported. Please provide a string input."
-        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

jaclang/core/llms/huggingface.py

@@ -1,76 +0,0 @@
-"""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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        assert isinstance(
-            meaning_in, str
-        ), "Currently Multimodal models are not supported. Please provide a string input."
-        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

@@ -1,81 +0,0 @@
-"""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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        assert isinstance(
-            meaning_in, str
-        ), "Currently Multimodal models are not supported. Please provide a string input."
-        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

@@ -1,65 +0,0 @@
-"""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 = str(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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        if not isinstance(meaning_in, str):
-            assert self.model_name.startswith(
-                ("gpt-4o", "gpt-4-turbo")
-            ), f"Model {self.model_name} is not multimodal, use a multimodal model instead."
-        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

@@ -1,63 +0,0 @@
-"""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 | list[dict], **kwargs: dict) -> str:
-        """Infer a response from the input meaning."""
-        assert isinstance(
-            meaning_in, str
-        ), "Currently Multimodal models are not supported. Please provide a string input."
-        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

@@ -1,9 +0,0 @@
-"""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__)