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

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__)