SimplerLLM 0.2.5__tar.gz → 0.2.6__tar.gz

{simplerllm-0.2.5 → simplerllm-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: SimplerLLM
-Version: 0.2.5
+Version: 0.2.6
 Summary: An easy-to-use Library for interacting with language models.
 Home-page: https://github.com/hassancs91/SimplerLLM
 Author: Hasan Aboul Hasan

simplerllm-0.2.6/SimplerLLM/agents/agent.py

@@ -0,0 +1,121 @@
+from SimplerLLM.language.llm import LLM, LLMProvider
+from SimplerLLM.tools.json_helpers import extract_json_from_text
+from SimplerLLM.tools.predefined_tools import PREDEFINED_TOOLS
+
+
+
+class Agent:
+    def __init__(self, llm_instace : LLM, verbose : bool = False):
+        self.verbose = verbose
+        self.llm_instance = llm_instace
+        self.available_actions = {}
+        self.system_prompt_template = """
+                You run in a loop of Thought, Action, PAUSE, Action_Response.
+                At the end of the loop you output an Answer.
+
+                Use Thought to understand the question you have been asked.
+                Use Action to run one of the actions available to you - then return PAUSE.
+                Action_Response will be the result of running those actions.
+
+                Your available actions are:
+
+                {actions_list}
+
+                To use an action, please use the following format:
+
+                Action:
+
+                {{
+                    "function_name": tool_name,
+                    "function_parms": {{
+                        "param": "value"
+                    }}
+                }}
+
+                Action_Response: the result of the action.
+
+                Final Answer:\n
+                
+            
+                """.strip()
+        
+
+        
+
+
+    def add_tool(self, tool_function):
+        if tool_function in PREDEFINED_TOOLS.values():
+            tool_name = [name for name, func in PREDEFINED_TOOLS.items() if func == tool_function][0]
+            description = tool_function.__doc__.strip()
+        elif hasattr(tool_function, 'is_custom_tool') and tool_function.is_custom_tool:
+            tool_name = tool_function.__name__
+            description = tool_function.description
+        else:
+            raise ValueError("Tool function must be predefined or decorated as a custom tool.")
+
+        self.available_actions[tool_name] = {
+            "function": tool_function,
+            "description": description
+        }
+
+
+
+    def construct_system_prompt(self):
+        actions_description = "\n".join(
+            [f"{name}:\n {details['description']}"
+             for name, details in self.available_actions.items()]
+        )
+        return self.system_prompt_template.format(actions_list=actions_description)
+
+    def generate_response(self, user_query, max_turns=5):
+        final_response = ""
+        react_system_prompt = self.construct_system_prompt()
+        messages = [
+            {"role": "system", "content": react_system_prompt},
+            {"role": "user", "content": user_query}
+        ]
+        turn_count = 1
+
+        while turn_count <= max_turns:
+            if self.verbose:
+                print(f"Loop: {turn_count}")
+                print("----------------------")
+
+            turn_count += 1
+
+            agent_response = self.llm_instance.generate_response(messages=messages)
+            messages.append({"role": "assistant", "content": agent_response})
+            final_response = agent_response
+            if self.verbose:
+                print(agent_response)
+
+            # Extract action JSON from text response.
+            action_json = extract_json_from_text(agent_response)
+            if action_json:
+                if 'function_name' in action_json[0]:
+                    function_name = action_json[0]['function_name']
+                    function_parms = action_json[0]['function_parms']
+                    if function_name not in self.available_actions:
+                        raise Exception(f"Unknown action: {function_name}: {function_parms}")
+                    if self.verbose:
+                        print(f" -- running {function_name} with {function_parms}")
+                    action_function = self.available_actions[function_name]["function"]
+                    result = action_function(**function_parms)
+                    if self.verbose:
+                        print("Action_Response:", result)
+                    function_result_message = f"Action_Response: {result}"
+                    messages.append({"role": "user", "content": function_result_message})
+                    if self.verbose:
+                        print("----------------------")
+                else:
+                    break
+            else:
+                break
+
+        #extract final answer from json
+        #answer_json = extract_json_from_text(final_response)
+        #answer = final_response.strip().split(":", 1)[1].strip()
+
+        return final_response
+
+

simplerllm-0.2.6/SimplerLLM/language/llm.py

@@ -0,0 +1,333 @@
+import SimplerLLM.language.llm_providers.openai_llm as openai_llm
+import SimplerLLM.language.llm_providers.gemini_llm as gemini_llm
+import SimplerLLM.language.llm_providers.anthropic_llm as anthropic_llm
+from SimplerLLM.prompts.messages_template import MessagesTemplate
+from enum import Enum
+
+
+class LLMProvider(Enum):
+    OPENAI = 1
+    GEMINI = 2
+    ANTHROPIC = 3
+
+
+class LLM:
+    def __init__(
+        self,
+        provider=LLMProvider.OPENAI,
+        model_name="gpt-3.5-turbo",
+        temperature=0.7,
+        top_p=1.0,
+    ):
+        self.provider = provider
+        self.model_name = model_name
+        self.temperature = temperature
+        self.top_p = top_p
+
+    @staticmethod
+    def create(
+        provider=None,
+        model_name=None,
+        temperature=0.7,
+        top_p=1.0,
+    ):
+        if provider == LLMProvider.OPENAI:
+            return OpenAILLM(provider, model_name, temperature, top_p)
+        if provider == LLMProvider.GEMINI:
+            return GeminiLLM(provider, model_name, temperature, top_p)
+        if provider == LLMProvider.ANTHROPIC:
+            return AnthropicLLM(provider, model_name, temperature, top_p)
+        else:
+            return None
+
+    def set_model(self, provider):
+        if not isinstance(provider, LLMProvider):
+            raise ValueError("Provider must be an instance of LLMProvider Enum")
+        self.provider = provider
+
+    def prepare_params(self, model_name, temperature, top_p):
+        # Use instance values as defaults if parameters are not provided
+        return {
+            "model_name": model_name if model_name else self.model_name,
+            "temperature": temperature if temperature else self.temperature,
+            "top_p": top_p if top_p else self.top_p,
+        }
+
+
+class OpenAILLM(LLM):
+    def __init__(self, model, model_name, temperature, top_p):
+        super().__init__(model, model_name, temperature, top_p)
+
+    
+    def append_messages(self, system_prompt : str, messages: list):
+        model_messages = [{"role": "system", "content": system_prompt}]
+        if messages:
+            model_messages.extend(messages)
+        return model_messages
+
+   
+
+    def generate_response(
+        self,
+        model_name: str =None,
+        prompt: str = None,
+        messages: list = None,
+        system_prompt: str="You are a helpful AI Assistant",
+        temperature: float=0.7,
+        max_tokens: int=300,
+        top_p: float=1.0,
+        full_response: bool=False,
+    ):
+        params = self.prepare_params(model_name, temperature, top_p)
+
+        # Validate inputs
+        if prompt and messages:
+            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
+        if not prompt and not messages:
+            raise ValueError("Either 'prompt' or 'messages' must be provided.")
+
+        # Prepare messages based on input type
+        if prompt:
+            model_messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt},
+            ]
+
+        if messages:
+            model_messages = self.append_messages(system_prompt, messages)
+
+
+
+        params.update(
+            {
+                "messages": model_messages,
+                "max_tokens": max_tokens,
+                "full_response": full_response,
+            }
+        )
+        return openai_llm.generate_response(**params)
+
+    async def generate_response_async(
+        self,
+        model_name: str =None,
+        prompt: str = None,
+        messages: list = None,
+        system_prompt: str="You are a helpful AI Assistant",
+        temperature: float=0.7,
+        max_tokens: int=300,
+        top_p: float=1.0,
+        full_response: bool=False,
+    ):
+        params = self.prepare_params(model_name, temperature, top_p)
+
+        # Validate inputs
+        if prompt and messages:
+            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
+        if not prompt and not messages:
+            raise ValueError("Either 'prompt' or 'messages' must be provided.")
+
+        # Prepare messages based on input type
+        if prompt:
+            model_messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt},
+            ]
+
+        if messages:
+            model_messages = self.append_messages(system_prompt, messages)
+
+
+        params.update(
+            {
+                "messages": model_messages,
+                "max_tokens": max_tokens,
+                "full_response": full_response,
+            }
+        )
+        return await openai_llm.generate_response_async(**params)
+
+
+class GeminiLLM(LLM):
+
+    def __init__(self, model, model_name, temperature, top_p):
+        super().__init__(model, model_name, temperature, top_p)
+
+    def convert_messages_template(self, messages):
+        # Convert the unified message template to Gemini's format
+        #return [{"role": msg["role"], "parts": [msg["content"]]} for msg in messages]
+        return [{"role": msg["role"], "parts": [{"text": msg["content"]}]} for msg in messages]
+
+    def append_messages(self, system_prompt, messages):
+        model_messages = [
+                {"role": "user", "parts": [{"text": system_prompt}]},
+                {"role": "model", "parts": [{"text": "ok, confirmed."}]},
+            ]
+        messages = self.convert_messages_template(messages)
+        model_messages.extend(messages)
+        return model_messages
+
+
+
+    def generate_response(
+        self,
+        model_name=None,
+        prompt=None,
+        messages=None,
+        system_prompt="You are a helpful AI Assistant",
+        temperature=0.7,
+        max_tokens=300,
+        top_p=1.0,
+        full_response=False,
+    ):
+        params = self.prepare_params(model_name, temperature, top_p)
+        # Validate inputs
+        if prompt and messages:
+            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
+        if not prompt and not messages:
+            raise ValueError("Either 'prompt' or 'messages' must be provided.")
+
+        if prompt:
+            model_messages = [
+                {"role": "user", "parts": [{"text": system_prompt}]},
+                {"role": "model", "parts": [{"text": "ok, confirmed."}]},
+                {"role": "user", "parts": [{"text": prompt}]}
+            ]
+
+        if messages:
+            model_messages = self.append_messages(system_prompt, messages)
+
+        params.update(
+            {
+                "messages": model_messages,
+                "system_prompt": system_prompt,
+                "max_tokens": max_tokens,
+                "full_response": full_response,
+            }
+        )
+        return gemini_llm.generate_response(**params)
+
+    async def generate_response_async(
+        self,
+        model_name=None,
+        prompt=None,
+        messages=None,
+        system_prompt="You are a helpful AI Assistant",
+        temperature=0.7,
+        max_tokens=300,
+        top_p=1.0,
+        full_response=False,
+    ):
+        params = self.prepare_params(model_name, temperature, top_p)
+        # Validate inputs
+        if prompt and messages:
+            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
+        if not prompt and not messages:
+            raise ValueError("Either 'prompt' or 'messages' must be provided.")
+
+        if prompt:
+            model_messages = [
+                {"role": "user", "parts": [{"text": system_prompt}]},
+                {"role": "model", "parts": [{"text": "ok, confirmed."}]},
+                {"role": "user", "parts": [{"text": prompt}]}
+            ]
+
+        if messages:
+            model_messages = self.append_messages(system_prompt, messages)
+        params.update(
+            {
+                "messages": model_messages,
+                "system_prompt": system_prompt,
+                "max_tokens": max_tokens,
+                "full_response": full_response,
+            }
+        )
+        return await gemini_llm.generate_response_async(**params)
+
+
+class AnthropicLLM(LLM):
+    def __init__(self, model, model_name, temperature, top_p):
+        super().__init__(model, model_name, temperature, top_p)
+    
+    def append_messages(self, messages: list):
+        model_messages = []
+        if messages:
+            model_messages.extend(messages)
+        return model_messages
+
+    def generate_response(
+        self,
+        model_name: str =None,
+        prompt: str = None,
+        messages: list = None,
+        system_prompt: str="You are a helpful AI Assistant",
+        temperature: float=0.7,
+        max_tokens: int=300,
+        top_p: float=1.0,
+        full_response: bool=False,
+    ):
+        params = self.prepare_params(model_name, temperature, top_p)
+
+        # Validate inputs
+        if prompt and messages:
+            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
+        if not prompt and not messages:
+            raise ValueError("Either 'prompt' or 'messages' must be provided.")
+
+        # Prepare messages based on input type
+        if prompt:
+            model_messages = [
+                {"role": "user", "content": prompt},
+            ]
+
+        if messages:
+            model_messages = self.append_messages(messages)
+
+        params.update(
+            {
+                "system_prompt": system_prompt,
+                "messages": model_messages,
+                "max_tokens": max_tokens,
+                "full_response": full_response,
+            }
+        )
+        return anthropic_llm.generate_response(**params)
+
+    async def generate_response_async(
+        self,
+        model_name=None,
+        prompt=None,
+        messages: list = None,
+        system_prompt="You are a helpful AI Assistant",
+        temperature=0.7,
+        max_tokens=300,
+        top_p=1.0,
+        full_response=False,
+    ):
+        params = self.prepare_params(model_name, temperature, top_p)
+
+        # Validate inputs
+        if prompt and messages:
+            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
+        if not prompt and not messages:
+            raise ValueError("Either 'prompt' or 'messages' must be provided.")
+
+        # Prepare messages based on input type
+        if prompt:
+            model_messages = [
+                {"role": "user", "content": prompt},
+            ]
+
+        if messages:
+            model_messages = self.append_messages(messages)
+
+        params.update(
+            {
+                "system_prompt": system_prompt,
+                "messages": model_messages,
+                "max_tokens": max_tokens,
+                "full_response": full_response,
+            }
+        )
+        return await anthropic_llm.generate_response_async(**params)
+
+

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM/language/llm_addons.py

@@ -18,6 +18,7 @@ def generate_pydantic_json_model(
     prompt: str,
     llm_instance: LLM,
     max_retries: int = 3,
+    max_tokens: int = 4096,
     initial_delay: float = 1.0,
     custom_prompt_suffix: str = None,
 ) -> BaseModel:
@@ -42,7 +43,7 @@ def generate_pydantic_json_model(
 
     for attempt, delay in enumerate(backoff_delays):
         try:
-            ai_response = llm_instance.generate_response(prompt=optimized_prompt)
+            ai_response = llm_instance.generate_response(prompt=optimized_prompt, max_tokens = max_tokens)
 
             if ai_response:
                 json_object = extract_json_from_text(ai_response)

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM/language/llm_providers/anthropic_llm.py

@@ -18,7 +18,6 @@ RETRY_DELAY = int(os.getenv("RETRY_DELAY", 2))
 
 def generate_response(
     model_name: str,
-    prompt: Optional[str] = None,
     system_prompt: str = "You are a helpful AI Assistant",
     messages=None,
     temperature: float = 0.7,
@@ -34,14 +33,7 @@ def generate_response(
     retry_attempts = 3
     retry_delay = 1  # initial delay between retries in seconds
 
-    if messages is None:
-        if prompt is None:
-            raise ValueError("Either 'prompt' or 'messages' must be provided.")
-        messages = [{"role": "user", "content": prompt}]
-    else:
-        if prompt is not None:
-            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
-        messages = messages
+
 
     # Define the URL and headers
     url = "https://api.anthropic.com/v1/messages"
@@ -88,7 +80,6 @@ def generate_response(
 
 async def generate_response_async(
     model_name: str,
-    prompt: Optional[str] = None,
     system_prompt: str = "You are a helpful AI Assistant",
     messages=None,
     temperature: float = 0.7,
@@ -104,15 +95,6 @@ async def generate_response_async(
     retry_attempts = 3
     retry_delay = 1  # initial delay between retries in seconds
 
-    if messages is None:
-        if prompt is None:
-            raise ValueError("Either 'prompt' or 'messages' must be provided.")
-        messages = [{"role": "user", "content": prompt}]
-    else:
-        if prompt is not None:
-            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
-        messages = messages
-
     # Define the URL and headers
     url = "https://api.anthropic.com/v1/messages"
     headers = {

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM/language/llm_providers/gemini_llm.py

@@ -19,7 +19,6 @@ RETRY_DELAY = int(os.getenv("RETRY_DELAY", 2))
 
 def generate_response(
     model_name: str,
-    prompt: Optional[str] = None,
     system_prompt: str = "You are a helpful AI Assistant",
     messages: Optional[List[Dict]] = None,
     temperature: float = 0.7,
@@ -52,32 +51,17 @@ def generate_response(
     url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent"
     headers = {"Content-Type": "application/json"}
 
-    if messages is None:
-        if prompt is None:
-            raise ValueError("Either 'prompt' or 'messages' must be provided.")
-        if system_prompt:
-            contents = [
-                {"role": "user", "parts": [{"text": system_prompt}]},
-                {"role": "model", "parts": [{"text": "ok"}]},
-                {"role": "user", "parts": [{"text": prompt}]},
-            ]
-        else:
-            contents = [{"role": "user", "parts": [{"text": prompt}]}]
-
-    else:
-        if prompt is not None:
-            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
-        if system_prompt:
-            contents = [
-                {"role": "user", "parts": [{"text": system_prompt}]},
-                {"role": "model", "parts": [{"text": "ok"}]},
-            ]
-            contents.append(messages)
-        else:
-            contents = messages
 
     payload = {
-        "contents": contents,
+        "contents": messages,
+        # "system_instruction":
+        #     {
+        #         "parts": [
+        #             {
+        #                 "text": system_prompt
+        #             }
+        #         ]
+        #     },
         "generationConfig": {
             "temperature": temperature,
             "maxOutputTokens": max_tokens,
@@ -116,7 +100,6 @@ def generate_response(
 
 async def generate_response_async(
     model_name: str,
-    prompt: Optional[str] = None,
     system_prompt: str = "You are a helpful AI Assistant",
     messages: Optional[List[Dict]] = None,
     temperature: float = 0.7,
@@ -150,32 +133,9 @@ async def generate_response_async(
     url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent"
     headers = {"Content-Type": "application/json"}
 
-    if messages is None:
-        if prompt is None:
-            raise ValueError("Either 'prompt' or 'messages' must be provided.")
-        if system_prompt:
-            contents = [
-                {"role": "user", "parts": [{"text": system_prompt}]},
-                {"role": "model", "parts": [{"text": "ok"}]},
-                {"role": "user", "parts": [{"text": prompt}]},
-            ]
-        else:
-            contents = [{"role": "user", "parts": [{"text": prompt}]}]
-
-    else:
-        if prompt is not None:
-            raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
-        if system_prompt:
-            contents = [
-                {"role": "user", "parts": [{"text": system_prompt}]},
-                {"role": "model", "parts": [{"text": "ok"}]},
-            ]
-            contents.append(messages)
-        else:
-            contents = messages
-
+    
     payload = {
-        "contents": contents,
+        "contents": messages,
         "generationConfig": {
             "temperature": temperature,
             "maxOutputTokens": max_tokens,

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM/language/llm_providers/openai_llm.py

@@ -28,9 +28,7 @@ async_openai_client, openai_client = initialize_openai_clients()
 
 def generate_response(
     model_name,
-    prompt=None,
     messages=None,
-    system_prompt="You are a helpful AI Assistant",
     temperature=0.7,
     max_tokens=300,
     top_p=1.0,
@@ -38,19 +36,7 @@ def generate_response(
 ):
     start_time = time.time() if full_response else None
 
-    # Validate inputs
-    if prompt and messages:
-        raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
-    if not prompt and not messages:
-        raise ValueError("Either 'prompt' or 'messages' must be provided.")
-
-    # Prepare messages based on input type
-    if prompt:
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": prompt},
-        ]
-
+    
     for attempt in range(MAX_RETRIES):
         try:
             completion = openai_client.chat.completions.create(
@@ -86,12 +72,9 @@ def generate_response(
                 print(error_msg)
                 return None
 
-
 async def generate_response_async(
     model_name,
-    prompt=None,
     messages=None,
-    system_prompt="You are a helpful AI Assistant",
     temperature=0.7,
     max_tokens=300,
     top_p=1.0,
@@ -99,19 +82,7 @@ async def generate_response_async(
 ):
     start_time = time.time() if full_response else None
 
-    # Validate inputs
-    if prompt and messages:
-        raise ValueError("Only one of 'prompt' or 'messages' should be provided.")
-    if not prompt and not messages:
-        raise ValueError("Either 'prompt' or 'messages' must be provided.")
-
-    # Prepare messages based on input type
-    if prompt:
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": prompt},
-        ]
-
+   
     for attempt in range(MAX_RETRIES):
         try:
             completion = await async_openai_client.chat.completions.create(

simplerllm-0.2.6/SimplerLLM/prompts/messages_template.py

@@ -0,0 +1,41 @@
+class MessagesTemplate:
+    def __init__(self):
+        self.messages = []
+
+    def add_user_message(self, content):
+        self.messages.append({"role": "user", "content": content})
+
+    def add_assistant_message(self, content):
+        self.messages.append({"role": "assistant", "content": content})
+
+    def validate_alternation(self):
+        if not self.messages:
+            return False, "MessageTemplate is empty."
+
+        if self.messages[0]["role"] != "user":
+            return False, "MessageTemplate must start with a user message."
+
+        if self.messages[-1]["role"] != "user":
+            return False, "MessageTemplate must end with a user message."
+
+        for i in range(len(self.messages) - 1):
+            if self.messages[i]["role"] == self.messages[i + 1]["role"]:
+                return False, f"Consecutive messages found at index {i} and {i + 1}."
+
+        return True, "MessageTemplate is valid."
+
+
+    def get_messages(self):
+        # Validate the message alternation
+        is_valid, validation_message = self.validate_alternation()
+        if is_valid:
+            return self.messages
+        else:
+            raise ValueError(validation_message)
+        
+
+    def __repr__(self):
+        return f"MessageTemplate({self.messages})"
+    
+
+

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM/tools/generic_loader.py

@@ -20,6 +20,31 @@ class TextDocument(BaseModel):
 
 
 def load_content(input_path_or_url):
+    """
+    Load content from a given input path or URL and return a TextDocument object.
+
+    This function handles the following types of input:
+    - URLs: Supports both YouTube videos and blog articles.
+        - For YouTube videos, it retrieves the title and transcript.
+        - For blog articles, it retrieves the text and title.
+    - Local files: Supports .txt, .csv, .docx, and .pdf file extensions.
+        - For each file type, it reads the content and calculates the file size, word count, and character count.
+
+    Args:
+        input_path_or_url (str): The path to a local file or a URL to online content.
+
+    Returns:
+        TextDocument: An object containing the following attributes:
+            - word_count (int): The number of words in the content.
+            - character_count (int): The number of characters in the content.
+            - content (str): The loaded content.
+            - file_size (int): The size of the content in bytes.
+            - url_or_path (str): The original input path or URL.
+            - title (str, optional): The title of the content (for YouTube videos and blog articles).
+
+    Raises:
+        ValueError: If the input cannot be processed or an error occurs during processing.
+    """
     # Check if the input is a URL
     if re.match(r"http[s]?://", input_path_or_url):
         # Process based on URL content

simplerllm-0.2.6/SimplerLLM/tools/predefined_tools.py

@@ -0,0 +1,6 @@
+from SimplerLLM.tools.generic_loader import load_content
+
+# List of predefined tools
+PREDEFINED_TOOLS = {
+    "load_content": load_content
+}

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: SimplerLLM
-Version: 0.2.5
+Version: 0.2.6
 Summary: An easy-to-use Library for interacting with language models.
 Home-page: https://github.com/hassancs91/SimplerLLM
 Author: Hasan Aboul Hasan

{simplerllm-0.2.5 → simplerllm-0.2.6}/SimplerLLM.egg-info/SOURCES.txt

@@ -6,6 +6,8 @@ SimplerLLM.egg-info/SOURCES.txt
 SimplerLLM.egg-info/dependency_links.txt
 SimplerLLM.egg-info/requires.txt
 SimplerLLM.egg-info/top_level.txt
+SimplerLLM/agents/__init__.py
+SimplerLLM/agents/agent.py
 SimplerLLM/image/__init__.py
 SimplerLLM/image/img_helper_funcs.py
 SimplerLLM/image/stability_ai.py
@@ -20,12 +22,14 @@ SimplerLLM/language/llm_providers/llm_response_models.py
 SimplerLLM/language/llm_providers/openai_llm.py
 SimplerLLM/language/llm_providers/transformers_llm.py
 SimplerLLM/prompts/__init__.py
+SimplerLLM/prompts/messages_template.py
 SimplerLLM/prompts/prompt_builder.py
 SimplerLLM/tools/__init__.py
 SimplerLLM/tools/file_functions.py
 SimplerLLM/tools/file_loader.py
 SimplerLLM/tools/generic_loader.py
 SimplerLLM/tools/json_helpers.py
+SimplerLLM/tools/predefined_tools.py
 SimplerLLM/tools/rapid_api.py
 SimplerLLM/tools/serp.py
 SimplerLLM/tools/text_chunker.py

{simplerllm-0.2.5 → simplerllm-0.2.6}/setup.py

@@ -11,7 +11,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="SimplerLLM",
-    version="0.2.5",
+    version="0.2.6",
     author="Hasan Aboul Hasan",
     author_email="hasan@learnwithhasan.com",
     description="An easy-to-use Library for interacting with language models.",

simplerllm-0.2.5/SimplerLLM/language/llm.py

@@ -1,208 +0,0 @@
-import SimplerLLM.language.llm_providers.openai_llm as openai_llm
-import SimplerLLM.language.llm_providers.gemini_llm as gemini_llm
-import SimplerLLM.language.llm_providers.anthropic_llm as anthropic_llm
-from enum import Enum
-
-
-class LLMProvider(Enum):
-    OPENAI = 1
-    GEMINI = 2
-    ANTHROPIC = 3
-
-
-class LLM:
-    def __init__(
-        self,
-        provider=LLMProvider.OPENAI,
-        model_name="gpt-3.5-turbo",
-        temperature=0.7,
-        top_p=1.0,
-    ):
-        self.provider = provider
-        self.model_name = model_name
-        self.temperature = temperature
-        self.top_p = top_p
-
-    @staticmethod
-    def create(
-        provider=None,
-        model_name=None,
-        temperature=0.7,
-        top_p=1.0,
-    ):
-        if provider == LLMProvider.OPENAI:
-            return OpenAILLM(provider, model_name, temperature, top_p)
-        if provider == LLMProvider.GEMINI:
-            return GeminiLLM(provider, model_name, temperature, top_p)
-        if provider == LLMProvider.ANTHROPIC:
-            return AnthropicLLM(provider, model_name, temperature, top_p)
-        else:
-            return None
-
-    def set_model(self, provider):
-        if not isinstance(provider, LLMProvider):
-            raise ValueError("Provider must be an instance of LLMProvider Enum")
-        self.provider = provider
-
-    def prepare_params(self, model_name, temperature, top_p):
-        # Use instance values as defaults if parameters are not provided
-        return {
-            "model_name": model_name if model_name else self.model_name,
-            "temperature": temperature if temperature else self.temperature,
-            "top_p": top_p if top_p else self.top_p,
-        }
-
-
-class OpenAILLM(LLM):
-    def __init__(self, model, model_name, temperature, top_p):
-        super().__init__(model, model_name, temperature, top_p)
-
-    def generate_response(
-        self,
-        model_name=None,
-        prompt=None,
-        messages=None,
-        system_prompt="You are a helpful AI Assistant",
-        temperature=0.7,
-        max_tokens=300,
-        top_p=1.0,
-        full_response=False,
-    ):
-        params = self.prepare_params(model_name, temperature, top_p)
-        params.update(
-            {
-                "prompt": prompt,
-                "messages": messages,
-                "system_prompt": system_prompt,
-                "max_tokens": max_tokens,
-                "full_response": full_response,
-            }
-        )
-        return openai_llm.generate_response(**params)
-
-    async def generate_response_async(
-        self,
-        model_name=None,
-        prompt=None,
-        messages=None,
-        system_prompt="You are a helpful AI Assistant",
-        temperature=0.7,
-        max_tokens=300,
-        top_p=1.0,
-        full_response=False,
-    ):
-        params = self.prepare_params(model_name, temperature, top_p)
-        params.update(
-            {
-                "prompt": prompt,
-                "messages": messages,
-                "system_prompt": system_prompt,
-                "max_tokens": max_tokens,
-                "full_response": full_response,
-            }
-        )
-        return await openai_llm.generate_response_async(**params)
-
-
-class GeminiLLM(LLM):
-    def __init__(self, model, model_name, temperature, top_p):
-        super().__init__(model, model_name, temperature, top_p)
-
-    def generate_response(
-        self,
-        model_name=None,
-        prompt=None,
-        messages=None,
-        system_prompt="You are a helpful AI Assistant",
-        temperature=0.7,
-        max_tokens=300,
-        top_p=1.0,
-        full_response=False,
-    ):
-        params = self.prepare_params(model_name, temperature, top_p)
-        params.update(
-            {
-                "prompt": prompt,
-                "messages": messages,
-                "system_prompt": system_prompt,
-                "max_tokens": max_tokens,
-                "full_response": full_response,
-            }
-        )
-        return gemini_llm.generate_response(**params)
-
-    async def generate_response_async(
-        self,
-        model_name=None,
-        prompt=None,
-        messages=None,
-        system_prompt="You are a helpful AI Assistant",
-        temperature=0.7,
-        max_tokens=300,
-        top_p=1.0,
-        full_response=False,
-    ):
-        params = self.prepare_params(model_name, temperature, top_p)
-        params.update(
-            {
-                "prompt": prompt,
-                "messages": messages,
-                "system_prompt": system_prompt,
-                "max_tokens": max_tokens,
-                "full_response": full_response,
-            }
-        )
-        return await gemini_llm.generate_response_async(**params)
-
-
-class AnthropicLLM(LLM):
-    def __init__(self, model, model_name, temperature, top_p):
-        super().__init__(model, model_name, temperature, top_p)
-
-    def generate_response(
-        self,
-        model_name=None,
-        prompt=None,
-        messages=None,
-        system_prompt="You are a helpful AI Assistant",
-        temperature=0.7,
-        max_tokens=300,
-        top_p=1.0,
-        full_response=False,
-    ):
-        params = self.prepare_params(model_name, temperature, top_p)
-        params.update(
-            {
-                "prompt": prompt,
-                "messages": messages,
-                "system_prompt": system_prompt,
-                "max_tokens": max_tokens,
-                "full_response": full_response,
-            }
-        )
-        return anthropic_llm.generate_response(**params)
-
-    async def generate_response_async(
-        self,
-        model_name=None,
-        prompt=None,
-        messages=None,
-        system_prompt="You are a helpful AI Assistant",
-        temperature=0.7,
-        max_tokens=300,
-        top_p=1.0,
-        full_response=False,
-    ):
-        params = self.prepare_params(model_name, temperature, top_p)
-        params.update(
-            {
-                "prompt": prompt,
-                "messages": messages,
-                "system_prompt": system_prompt,
-                "max_tokens": max_tokens,
-                "full_response": full_response,
-            }
-        )
-        return await anthropic_llm.generate_response_async(**params)
-
-