LLMFunctionObjects 0.1.7__tar.gz → 0.2.0__tar.gz

{llmfunctionobjects-0.1.7 → llmfunctionobjects-0.2.0}/LLMFunctionObjects/Evaluator.py

@@ -72,8 +72,7 @@ class Evaluator:
         return resLocal
 
     # This is a generic LLM evaluator method
-    # that works for OpenAI's text completions, and
-    # PaLM's text generation.
+    # that works for OpenAI's text completions.
     # The children classes override this method completely.
     # (instead of reusing it because of logging, etc.)
     def eval(self, texts, **args):

{llmfunctionobjects-0.1.7 → llmfunctionobjects-0.2.0}/LLMFunctionObjects/EvaluatorChatGPT.py

@@ -20,5 +20,14 @@ class EvaluatorChatGPT(EvaluatorChat):
         return res_messages
 
     def result_values(self, res):
-        resLocal = res.choices[0].message.content
-        return resLocal
+        # Support both Chat Completions and Responses API shapes.
+        if hasattr(res, "output_text") and res.output_text is not None:
+            return res.output_text
+        if hasattr(res, "choices"):
+            return res.choices[0].message.content
+        if isinstance(res, dict):
+            if "output_text" in res and res["output_text"] is not None:
+                return res["output_text"]
+            if "choices" in res and res["choices"]:
+                return res["choices"][0]["message"]["content"]
+        return res

llmfunctionobjects-0.2.0/LLMFunctionObjects/EvaluatorChatGemini.py

@@ -0,0 +1,91 @@
+import google.generativeai as genai
+
+from LLMFunctionObjects.EvaluatorChat import EvaluatorChat
+from LLMFunctionObjects.EvaluatorGemini import _extract_gemini_text
+
+
+class EvaluatorChatGemini(EvaluatorChat):
+    def eval(self, texts, **args):
+        confDict = self.conf.to_dict()
+
+        echo = args.get("echo", False)
+        if echo:
+            print(f"Configuration: {self.conf}")
+
+        args2 = {**self.conf.to_dict(), **args}
+
+        # Handle argument renames
+        for k, v in confDict["argument_renames"].items():
+            args2[v] = args2.get(v, args2.get(k, None))
+
+        # Build context
+        delim = confDict["prompt_delimiter"] or "\n"
+        context = self.context or ""
+        fullPrompt = delim.join(confDict["prompts"])
+        if fullPrompt and context:
+            context = delim.join([fullPrompt, context])
+        elif fullPrompt:
+            context = fullPrompt
+
+        if echo:
+            print(f"Context: {context}")
+
+        # Form messages
+        messages = self.prompt_texts_combiner(prompt="", texts=texts, context=context)
+
+        if echo:
+            print(f"Messages: {messages}")
+
+        # Extract system instruction if present
+        system_instruction = None
+        if messages and list(messages[0].keys())[0] == self.system_role:
+            system_instruction = list(messages[0].values())[0]
+            messages = messages[1:]
+
+        # Map roles to Gemini format
+        res_messages = []
+        for d in messages:
+            role, content = list(d.items())[0]
+            if role == self.assistant_role:
+                role = "model"
+            elif role == self.user_role:
+                role = "user"
+            res_messages.append({"role": role, "parts": [content]})
+
+        model_name = args2.get("model", self.conf.model)
+        tools = args2.get("tools", None)
+        tool_config = args2.get("tool_config", None)
+        model_init_args = {}
+        if system_instruction:
+            model_init_args["system_instruction"] = system_instruction
+        if tools is not None:
+            model_init_args["tools"] = tools
+        if tool_config is not None:
+            model_init_args["tool_config"] = tool_config
+
+        try:
+            model = genai.GenerativeModel(model_name, **model_init_args)
+        except TypeError:
+            # Fallback for older google-generativeai versions
+            model = genai.GenerativeModel(model_name)
+            if system_instruction:
+                res_messages.insert(0, {"role": "user", "parts": [system_instruction]})
+
+        model_args = {
+            "generation_config": args2.get("generation_config", None),
+            "safety_settings": args2.get("safety_settings", None),
+            "tools": None,
+            "tool_config": None,
+            "stream": args2.get("stream", None),
+            "request_options": args2.get("request_options", None),
+        }
+        model_args = {k: v for k, v in model_args.items() if v is not None}
+
+        self.llm_result = None
+        res = model.generate_content(res_messages, **model_args)
+        self.llm_result = res
+
+        if echo:
+            print(f"LLM result: {res}")
+
+        return self.post_process(_extract_gemini_text(res), form=args.get("form", None))

llmfunctionobjects-0.2.0/LLMFunctionObjects/EvaluatorChatOllama.py

@@ -0,0 +1,58 @@
+import ollama
+
+from LLMFunctionObjects.EvaluatorChat import EvaluatorChat
+from LLMFunctionObjects.EvaluatorOllama import _extract_ollama_text
+
+
+class EvaluatorChatOllama(EvaluatorChat):
+    def _to_ollama_messages(self, messages):
+        res_messages = []
+        for d in messages:
+            for k, v in d.items():
+                res_messages.append({"role": k, "content": v})
+        return res_messages
+
+    def eval(self, texts, **args):
+        confDict = self.conf.to_dict()
+
+        echo = args.get("echo", False)
+        if echo:
+            print(f"Configuration: {self.conf}")
+
+        args2 = {**self.conf.to_dict(), **args}
+
+        # Handle argument renames
+        for k, v in confDict["argument_renames"].items():
+            args2[v] = args2.get(v, args2.get(k, None))
+
+        # Build context
+        delim = confDict["prompt_delimiter"] or "\n"
+        context = self.context or ""
+        fullPrompt = delim.join(confDict["prompts"])
+        if fullPrompt and context:
+            context = delim.join([fullPrompt, context])
+        elif fullPrompt:
+            context = fullPrompt
+
+        # Form messages
+        messages = self.prompt_texts_combiner(prompt="", texts=texts, context=context)
+        res_messages = self._to_ollama_messages(messages)
+
+        if echo:
+            print(f"Messages: {res_messages}")
+
+        model_name = args2.get("model", self.conf.model)
+
+        known_params = set(self.conf.known_params or [])
+        args3 = {k: v for k, v in args2.items() if k in known_params}
+        args3["model"] = model_name
+        args3["messages"] = res_messages
+
+        self.llm_result = None
+        res = ollama.chat(**args3)
+        self.llm_result = res
+
+        if echo:
+            print(f"LLM result: {res}")
+
+        return self.post_process(_extract_ollama_text(res), form=args.get("form", None))

llmfunctionobjects-0.2.0/LLMFunctionObjects/EvaluatorChatPaLM.py

@@ -0,0 +1,13 @@
+import warnings
+
+from LLMFunctionObjects.EvaluatorChatGemini import EvaluatorChatGemini
+
+
+class EvaluatorChatPaLM(EvaluatorChatGemini):
+    def __init__(self, **kwargs):
+        warnings.warn(
+            "PaLM is deprecated and has been replaced with Gemini. "
+            "Use EvaluatorChatGemini or llm_configuration('ChatGemini').",
+            DeprecationWarning,
+        )
+        super().__init__(**kwargs)

llmfunctionobjects-0.2.0/LLMFunctionObjects/EvaluatorGemini.py

@@ -0,0 +1,84 @@
+import google.generativeai as genai
+
+from LLMFunctionObjects.Evaluator import Evaluator
+
+
+def _extract_gemini_text(res):
+    if hasattr(res, "text") and res.text is not None:
+        return res.text
+    if isinstance(res, dict):
+        if "text" in res and res["text"] is not None:
+            return res["text"]
+    if hasattr(res, "candidates") and res.candidates:
+        cand = res.candidates[0]
+        if hasattr(cand, "content") and hasattr(cand.content, "parts"):
+            parts = cand.content.parts
+            if parts:
+                if isinstance(parts[0], str):
+                    return "".join(parts)
+                if hasattr(parts[0], "text"):
+                    return "".join([p.text for p in parts if hasattr(p, "text")])
+    return res
+
+
+class EvaluatorGemini(Evaluator):
+    def eval(self, texts, **args):
+        confDict = self.conf.to_dict()
+
+        echo = args.get("echo", False)
+        if echo:
+            print(f"Configuration: {self.conf}")
+
+        args2 = {**self.conf.to_dict(), **args}
+
+        # Handle argument renames
+        for k, v in confDict["argument_renames"].items():
+            args2[v] = args2.get(v, args2.get(k, None))
+
+        # Build prompt
+        fullPrompt = confDict["prompt_delimiter"].join(confDict["prompts"])
+        prompt = self.prompt_texts_combiner(fullPrompt, texts)
+
+        if echo:
+            print(f"Prompt: {prompt}")
+
+        # Configure model
+        model_name = args2.get("model", self.conf.model)
+        system_instruction = args2.get("system_instruction", None)
+        tools = args2.get("tools", None)
+        tool_config = args2.get("tool_config", None)
+        model_init_args = {}
+        if system_instruction:
+            model_init_args["system_instruction"] = system_instruction
+        if tools is not None:
+            model_init_args["tools"] = tools
+        if tool_config is not None:
+            model_init_args["tool_config"] = tool_config
+
+        try:
+            model = genai.GenerativeModel(model_name, **model_init_args)
+        except TypeError:
+            # Fallback for older google-generativeai versions
+            model = genai.GenerativeModel(model_name)
+            if system_instruction:
+                prompt = f"{system_instruction}\n\n{prompt}"
+
+        model_args = {
+            "generation_config": args2.get("generation_config", None),
+            "safety_settings": args2.get("safety_settings", None),
+            "tools": None,
+            "tool_config": None,
+            "stream": args2.get("stream", None),
+            "request_options": args2.get("request_options", None),
+        }
+        model_args = {k: v for k, v in model_args.items() if v is not None}
+
+        # Invoke Gemini
+        self.llm_result = None
+        res = model.generate_content(prompt, **model_args)
+        self.llm_result = res
+
+        if echo:
+            print(f"LLM result: {res}")
+
+        return self.post_process(_extract_gemini_text(res), form=args.get("form", None))

llmfunctionobjects-0.2.0/LLMFunctionObjects/EvaluatorOllama.py

@@ -0,0 +1,53 @@
+import ollama
+
+from LLMFunctionObjects.Evaluator import Evaluator
+
+
+def _extract_ollama_text(res):
+    if isinstance(res, dict):
+        if "response" in res:
+            return res["response"]
+        if "message" in res and isinstance(res["message"], dict):
+            return res["message"].get("content", res)
+    if hasattr(res, "response"):
+        return res.response
+    if hasattr(res, "message") and hasattr(res.message, "content"):
+        return res.message.content
+    return res
+
+
+class EvaluatorOllama(Evaluator):
+    def eval(self, texts, **args):
+        confDict = self.conf.to_dict()
+
+        echo = args.get("echo", False)
+        if echo:
+            print(f"Configuration: {self.conf}")
+
+        args2 = {**self.conf.to_dict(), **args}
+
+        # Handle argument renames
+        for k, v in confDict["argument_renames"].items():
+            args2[v] = args2.get(v, args2.get(k, None))
+
+        fullPrompt = confDict["prompt_delimiter"].join(confDict["prompts"])
+        prompt = self.prompt_texts_combiner(fullPrompt, texts)
+
+        if echo:
+            print(f"Prompt: {prompt}")
+
+        model_name = args2.get("model", self.conf.model)
+
+        known_params = set(self.conf.known_params or [])
+        args3 = {k: v for k, v in args2.items() if k in known_params}
+        args3["model"] = model_name
+        args3["prompt"] = prompt
+
+        self.llm_result = None
+        res = ollama.generate(**args3)
+        self.llm_result = res
+
+        if echo:
+            print(f"LLM result: {res}")
+
+        return self.post_process(_extract_ollama_text(res), form=args.get("form", None))

{llmfunctionobjects-0.1.7 → llmfunctionobjects-0.2.0}/LLMFunctionObjects/LLMFunctions.py

@@ -5,12 +5,14 @@ from LLMFunctionObjects.Configuration import Configuration
 from LLMFunctionObjects.Evaluator import Evaluator
 from LLMFunctionObjects.EvaluatorChat import EvaluatorChat
 from LLMFunctionObjects.EvaluatorChatGPT import EvaluatorChatGPT
-from LLMFunctionObjects.EvaluatorChatPaLM import EvaluatorChatPaLM
+from LLMFunctionObjects.EvaluatorChatGemini import EvaluatorChatGemini
+from LLMFunctionObjects.EvaluatorGemini import EvaluatorGemini
+from LLMFunctionObjects.EvaluatorChatOllama import EvaluatorChatOllama
+from LLMFunctionObjects.EvaluatorOllama import EvaluatorOllama
 from LLMFunctionObjects.Functor import Functor
 from LLMFunctionObjects.Chat import Chat
 import openai
-import google.generativeai
-import warnings
+import google.generativeai as genai
 
 
 # ===========================================================
@@ -54,15 +56,21 @@ def llm_configuration(spec, **kwargs):
         apiKey = kwargs.get("api_key", apiKey)
         client = openai.OpenAI(api_key=apiKey)
 
+        default_chat_model = os.environ.get("OPENAI_CHAT_MODEL", os.environ.get("OPENAI_MODEL", "gpt-4.1-mini"))
+
         confChatGPT = llm_configuration("openai",
                                         name="chatgpt",
                                         module='openai',
-                                        model='gpt-3.5-turbo',
+                                        model=default_chat_model,
                                         function=client.chat.completions.create,  # was openai.ChatCompletion.create,
+                                        argument_renames={"max_tokens": "max_completion_tokens"},
                                         known_params=["model", "messages", "functions", "function_call",
-                                                      "temperature", "top_p", "n",
-                                                      "stream", "logprobs", "stop", "presence_penalty",
-                                                      "frequency_penalty", "logit_bias",
+                                                      "tools", "tool_choice", "response_format",
+                                                      "temperature", "top_p", "n", "seed",
+                                                      "stream", "logprobs", "stop",
+                                                      "presence_penalty", "frequency_penalty", "logit_bias",
+                                                      "max_completion_tokens",
+                                                      "max_tokens",
                                                       "user"],
                                         response_value_keys=[])
 
@@ -73,78 +81,99 @@ def llm_configuration(spec, **kwargs):
         confChatGPT.llm_evaluator = None
 
         return confChatGPT
-    elif isinstance(spec, str) and spec.lower() == 'PaLM'.lower():
+    elif isinstance(spec, str) and spec.lower() == 'Gemini'.lower():
 
         # Set key
-        apiKey = os.environ.get("PALM_API_KEY")
+        apiKey = os.environ.get("GEMINI_API_KEY", os.environ.get("GOOGLE_API_KEY"))
         apiKey = kwargs.get("api_key", apiKey)
-        google.generativeai.configure(api_key=apiKey)
+        genai.configure(api_key=apiKey)
+
+        default_gemini_model = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash")
 
-        # Configuration
-        confPaLM = Configuration(
-            name="palm",
+        confGemini = Configuration(
+            name="gemini",
             api_key=None,
             api_user_id="user",
             module="google.generativeai",
-            model="models/text-bison-001",
-            function=google.generativeai.generate_text,
+            model=default_gemini_model,
+            function=None,
             temperature=0.2,
             max_tokens=300,
             total_probability_cutoff=0.03,
             prompts=None,
             prompt_delimiter=" ",
             stop_tokens=None,
-            argument_renames={"max_tokens": "max_output_tokens",
-                              "stop_tokens": "stop_sequences"},
+            argument_renames={},
             fmt="values",
             known_params=[
-                "model", "prompt", "temperature", "candidate_count", "max_output_tokens", "top_p", "top_k",
-                "safety_settings", "stop_sequences", "client"
+                "model", "generation_config", "safety_settings", "tools", "tool_config",
+                "stream", "request_options", "system_instruction"
             ],
-            response_object_attribute="result",
+            response_object_attribute=None,
             response_value_keys=[],
             llm_evaluator=None)
 
-        # Modify by additional arguments
         if len(kwargs) > 0:
-            confPaLM = confPaLM.combine(kwargs)
+            confGemini = confGemini.combine(kwargs)
+        return confGemini
 
-        # Result
-        return confPaLM
+    elif isinstance(spec, str) and spec.lower() == 'ChatGemini'.lower():
 
-    elif isinstance(spec, str) and spec.lower() == 'ChatPaLM'.lower():
-
-        # Start as PaLM text completion configuration
-        confChatPaLM = llm_configuration("PaLM")
+        confChatGemini = llm_configuration("Gemini")
+        confChatGemini.name = "chatgemini"
 
-        # Default PaLM chat model
-        confChatPaLM.model = 'models/chat-bison-001'
+        if len(kwargs) > 0:
+            confChatGemini = confChatGemini.combine(kwargs)
 
-        # Function
-        confChatPaLM.function = google.generativeai.chat
+        return confChatGemini
 
-        # Get result
-        # https://developers.generativeai.google/api/python/google/generativeai/types/ChatResponse
-        confChatPaLM.response_object_attribute = "last"
+    elif isinstance(spec, str) and spec.lower() == 'PaLM'.lower():
+        warnings.warn("PaLM is deprecated; using Gemini instead.", DeprecationWarning)
+        return llm_configuration('Gemini', **kwargs)
 
-        # The parameters are taken from here:
-        #   https://github.com/google/generative-ai-python/blob/f370f5ab908a095282a0cdd946385db23c695498/google/generativeai/discuss.py#L210
-        # and used in EvaluatorChatPaLM.eval
-        confChatPaLM.known_params = [
-            "model", "context", "examples", "temperature", "candidate_count", "top_p", "top_k", "prompt"
-        ]
+    elif isinstance(spec, str) and spec.lower() == 'ChatPaLM'.lower():
+        warnings.warn("ChatPaLM is deprecated; using ChatGemini instead.", DeprecationWarning)
+        return llm_configuration('ChatGemini', **kwargs)
 
-        # Adding it this for consistency
-        confChatPaLM.response_value_keys = None
+    elif isinstance(spec, str) and spec.lower() == 'Ollama'.lower():
+        default_ollama_model = os.environ.get("OLLAMA_MODEL", "llama3.2")
 
-        # Evaluator class
-        confChatPaLM.llm_evaluator = None
+        confOllama = Configuration(
+            name="ollama",
+            api_key=None,
+            api_user_id="user",
+            module="ollama",
+            model=default_ollama_model,
+            function=None,
+            temperature=0.2,
+            max_tokens=300,
+            total_probability_cutoff=0.03,
+            prompts=None,
+            prompt_delimiter=" ",
+            stop_tokens=None,
+            argument_renames={},
+            fmt="values",
+            known_params=[
+                "model", "prompt", "system", "template", "context", "stream",
+                "raw", "format", "options", "keep_alive"
+            ],
+            response_object_attribute=None,
+            response_value_keys=[],
+            llm_evaluator=None)
 
-        # Combine with given additional parameters (if any)
         if len(kwargs) > 0:
-            confChatPaLM = confChatPaLM.combine(kwargs)
-
-        return confChatPaLM
+            confOllama = confOllama.combine(kwargs)
+        return confOllama
+
+    elif isinstance(spec, str) and spec.lower() == 'ChatOllama'.lower():
+        confChatOllama = llm_configuration("Ollama")
+        confChatOllama.name = "chatollama"
+        confChatOllama.known_params = [
+            "model", "messages", "tools", "stream", "format", "options", "keep_alive"
+        ]
+        if len(kwargs) > 0:
+            confChatOllama = confChatOllama.combine(kwargs)
+        return confChatOllama
     else:
         warnings.warn(f"Do not know what to do with given configuration spec: {spec}. Continuing with \"OpenAI\".")
         return llm_configuration('OpenAI', **kwargs)
@@ -163,8 +192,14 @@ def llm_evaluator(spec, **args):
                 evaluator_class = EvaluatorChatGPT
             elif spec.name.lower() == "OpenAI".lower():
                 evaluator_class = Evaluator
-            elif spec.name.lower() == "PaLM".lower():
-                evaluator_class = EvaluatorChatPaLM
+            elif spec.name.lower() in ["Gemini".lower(), "PaLM".lower()]:
+                evaluator_class = EvaluatorGemini
+            elif spec.name.lower() in ["ChatGemini".lower(), "ChatPaLM".lower()]:
+                evaluator_class = EvaluatorChatGemini
+            elif spec.name.lower() == "Ollama".lower():
+                evaluator_class = EvaluatorOllama
+            elif spec.name.lower() == "ChatOllama".lower():
+                evaluator_class = EvaluatorChatOllama
             else:
                 raise ValueError(
                     'Cannot automatically deduce llm_evaluator_class from the given configuration object.')
@@ -335,7 +370,7 @@ def llm_synthesize(prompts, prop=None, **kwargs):
 # Chat object creation
 # ===========================================================
 
-_mustPassConfKeys = ["name", "prompts", "examples", "temperature", "max_tokens",
+_mustPassConfKeys = ["name", "model", "prompts", "examples", "temperature", "max_tokens",
                      "stop_tokens", "api_key", "api_user_id"]
 
 
@@ -366,10 +401,14 @@ def llm_chat(prompt: str = '', **kwargs):
 
         # Obtain Evaluator class
         if evaluator_class is None:
-            if 'palm' in conf.name.lower():
-                conf = llm_configuration('ChatPaLM',
+            if 'gemini' in conf.name.lower() or 'palm' in conf.name.lower():
+                conf = llm_configuration('ChatGemini',
+                                         **{k: v for k, v in conf.to_dict().items() if k in _mustPassConfKeys})
+                evaluator_class = EvaluatorChatGemini
+            elif 'ollama' in conf.name.lower():
+                conf = llm_configuration('ChatOllama',
                                          **{k: v for k, v in conf.to_dict().items() if k in _mustPassConfKeys})
-                evaluator_class = EvaluatorChatPaLM
+                evaluator_class = EvaluatorChatOllama
             else:
                 evaluator_class = EvaluatorChatGPT
 

{llmfunctionobjects-0.1.7 → llmfunctionobjects-0.2.0}/LLMFunctionObjects/__init__.py

@@ -3,6 +3,10 @@ from LLMFunctionObjects.Configuration import Configuration
 from LLMFunctionObjects.Evaluator import Evaluator
 from LLMFunctionObjects.EvaluatorChat import EvaluatorChat
 from LLMFunctionObjects.EvaluatorChatGPT import EvaluatorChatGPT
+from LLMFunctionObjects.EvaluatorChatGemini import EvaluatorChatGemini
+from LLMFunctionObjects.EvaluatorGemini import EvaluatorGemini
+from LLMFunctionObjects.EvaluatorChatOllama import EvaluatorChatOllama
+from LLMFunctionObjects.EvaluatorOllama import EvaluatorOllama
 from LLMFunctionObjects.EvaluatorChatPaLM import EvaluatorChatPaLM
 from LLMFunctionObjects.Functor import Functor
 from LLMFunctionObjects.Chat import Chat
@@ -18,4 +22,4 @@ from LLMFunctionObjects.SubParser import exact_parser
 from LLMFunctionObjects.SubParser import catch_by_pattern
 from LLMFunctionObjects.SubParser import extract_json_objects
 from LLMFunctionObjects.SubParser import jsonify_text
-from LLMFunctionObjects.SubParser import numify_text
+from LLMFunctionObjects.SubParser import numify_text