SimplerLLM 0.1.0__tar.gz

SimplerLLM-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.1
+Name: SimplerLLM
+Version: 0.1.0
+Summary: An easy-to-use Library for interacting with language models.
+Home-page: https://github.com/hassancs91/SimplerLLM
+Author: Hasan Aboul Hasan
+Author-email: hasan@learnwithhasan.com
+Keywords: text generation,openai,LLM,RAG
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+
+# ⚪ SimplerLLM (Beta)
+
+⚡ Your Easy Pass to Advanced AI ⚡
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+## 🤔 What is SimplerLLM?
+
+SimplerLLM is an open-source Python library designed to simplify interactions with Large Language Models (LLMs) for researchers and beginners. It offers a unified interface for different LLM providers and a suite of tools to enhance language model capabilities and make it Super easy for anyone to develop AI-powered tools and apps.
+
+## Easy Installation
+With pip:
+```bash
+pip install simplerllm
+```
+
+
+## Features
+
+- **Unified LLM Interface**: Define an LLM instance in one line for providers like OpenAI and Google Gemini. Future versions will support more APIs and LLM providers.
+- **Generic Text Loader**: Load text from various sources like DOCX, PDF, TXT files, YouTube scripts, or blog posts.
+- **RapidAPI Connector**: Connect with AI services on RapidAPI.
+- **SERP Integration**: Perform searches using DuckDuckGo, with more search engines coming soon.
+- **Prompt Template Builder**: Easily create and manage prompt templates.
+And Much More Coming Soon!
+
+
+### Creating an LLM Instance
+
+```python
+from SimplerLLM import LLM, LLMProvider
+
+# For OpenAI
+llm_instance = LLM.create(provider=LLMProvider.OPENAI)
+# For Google Gemini
+gemini_instance = LLM.create(provider=LLMProvider.GEMENI, model_name="gemini-pro")
+
+response = llm_instance.generate_text(user_prompt="generate a 5 words sentence")
+
+```
+
+### Using Tools
+
+#### SERP
+```python
+from SimplerLLM.tools.serp import search_with_duck_duck_go
+
+search_results = search_with_duck_duck_go("penut",3)
+
+# use the search results the way you want!
+
+```
+
+#### Generic Text Loader
+```python
+from SimplerLLM.tools.generic_text_loader import load_text
+
+text_file = load_text("file.txt")
+
+print(text_file.content)
+
+```
+
+#### Calling any RapidAPI API
+```python
+from  SimplerLLM.tools.rapid_api import RapidAPIClient
+
+api_url = "https://domain-authority1.p.rapidapi.com/seo/get-domain-info"
+api_params = {
+    'domain': 'learnwithhasan.com',
+}
+
+api_client = RapidAPIClient()  # API key read from environment variable
+response = api_client.call_api(api_url, method='GET', params=api_params)
+
+
+```
+
+
+#### Prompt Template Builder
+
+```python
+from SimplerLLM.prompts.prompt_builder import create_multi_value_prompts,create_prompt_template
+
+basic_prompt = "Generate 5 titles for a blog about {topic} and {style}"
+
+prompt_template = pr.create_prompt_template(basic_prompt)
+
+prompt_template.assign_parms(topic = "marketing",style = "catchy")
+
+print(prompt_template.content)
+
+
+## working with multiple value prompts
+multi_value_prompt_template = """Hello {name}, your next meeting is on {date}.
+ and bring a {object} wit you"""
+
+params_list = [
+     {"name": "Alice", "date": "January 10th", "object" : "dog"},
+     {"name": "Bob", "date": "January 12th", "object" : "bag"},
+     {"name": "Charlie", "date": "January 15th", "object" : "pen"} 
+]
+
+
+multi_value_prompt = create_multi_value_prompts(multi_value_prompt_template)
+generated_prompts = multi_value_prompt.generate_prompts(params_list)
+
+print(generated_prompts[0])
+
+```
+
+
+
+### Next Updates
+- Adding More Tools
+- Interacting With Local LLMs
+- Prompt Optimization
+- Response Evaluation
+- GPT Trainer
+- Document Chunker
+- Advanced Document Loader
+- Integration With More Providers 
+
+
+
+## License
+### MIT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

SimplerLLM-0.1.0/SimplerLLM/langauge/llm.py

@@ -0,0 +1,136 @@
+import SimplerLLM.langauge.llm_providers.openai_llm as openai_llm
+import SimplerLLM.langauge.llm_providers.gemeni_llm as gemeni_llm
+from enum import Enum
+
+
+class LLMProvider(Enum):
+    OPENAI = 1
+    GEMENI = 2
+
+
+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=LLMProvider.OPENAI, model_name="gpt-3.5-turbo", temperature=0.7,top_p=1.0):
+        if provider == LLMProvider.OPENAI:
+            return OpenAILLM(provider, model_name, temperature, top_p)
+        if provider == LLMProvider.GEMENI:
+            return GemeniLLM(provider, model_name, temperature,top_p)
+        else:
+            return LLM(provider, model_name, temperature)
+
+    def set_model(self, provider):
+        if not isinstance(provider, LLMProvider):
+            raise ValueError("Provider must be an instance of LLMProvider Enum")
+        self.provider = provider
+
+
+    def generate_text(self, input_text):
+        if self.provider == LLMProvider.OPENAI:
+            return openai_llm.generate(input_text)
+        elif self.provider == LLMProvider.GEMENI:
+            return "generated with Gemeni"
+        else:
+            raise ValueError("Unsupported model")
+
+
+
+ 
+ 
+
+class OpenAILLM(LLM):
+    def __init__(self, model, model_name, temperature,top_p):
+        super().__init__(model, model_name, temperature,top_p)
+
+
+
+    def generate_text(self, user_prompt, system_prompt="", model_name=None, temperature=None, top_p=None, max_tokens=500):
+        # Use instance values as defaults if not provided
+        model_name = model_name if model_name is not None else self.model_name
+        temperature = temperature if temperature is not None else self.temperature
+        top_p = top_p if top_p is not None else self.top_p
+
+        return openai_llm.generate_text(user_prompt=user_prompt, system_prompt=system_prompt, 
+                                        model=model_name, temperature=temperature, 
+                                        top_p=top_p, max_tokens=max_tokens)
+    
+    async def generate_text_async(self, user_prompt, system_prompt="", model_name=None, temperature=None, top_p=None, max_tokens=500):
+        # Use instance values as defaults if not provided
+        model_name = model_name if model_name is not None else self.model_name
+        temperature = temperature if temperature is not None else self.temperature
+        top_p = top_p if top_p is not None else self.top_p
+
+        return await openai_llm.generate_text_async(user_prompt=user_prompt, system_prompt=system_prompt, 
+                                        model=model_name, temperature=temperature, 
+                                        top_p=top_p, max_tokens=max_tokens)
+    
+    def generate_full_response(self, user_prompt, system_prompt="", model_name=None, temperature=None, top_p=None, max_tokens=500):
+        # Use instance values as defaults if not provided
+        model_name = model_name if model_name is not None else self.model_name
+        temperature = temperature if temperature is not None else self.temperature
+        top_p = top_p if top_p is not None else self.top_p
+
+        return openai_llm.generate_full_response(user_prompt=user_prompt, system_prompt=system_prompt, 
+                                        model=model_name, temperature=temperature, 
+                                        top_p=top_p, max_tokens=max_tokens)
+    
+    async def generate_full_response_async(self, user_prompt, system_prompt="", model_name=None, temperature=None, top_p=None, max_tokens=500):
+        # Use instance values as defaults if not provided
+        model_name = model_name if model_name is not None else self.model_name
+        temperature = temperature if temperature is not None else self.temperature
+        top_p = top_p if top_p is not None else self.top_p
+
+        return await openai_llm.generate_full_response_async(user_prompt=user_prompt, system_prompt=system_prompt, 
+                                        model=model_name, temperature=temperature, 
+                                        top_p=top_p, max_tokens=max_tokens)
+    
+    def generate_json_with_pydantic(self, user_prompt, pydantic_model,model_name):
+        return openai_llm.generate_json_with_pydantic(user_prompt=user_prompt,pydantic_model = pydantic_model,model_name=model_name)
+    
+    async def generate_json_with_pydantic_async(self, user_prompt, pydantic_model,model_name):
+        return await openai_llm.generate_json_with_pydantic_async(user_prompt=user_prompt,pydantic_model = pydantic_model,model_name=model_name)
+
+
+
+
+
+    
+class GemeniLLM(LLM):
+    def __init__(self, model, model_name, temperature,top_p):
+        super().__init__(model, model_name, temperature,top_p)
+
+    def generate_text(self, user_prompt,  model_name=None, temperature=None, top_p=None, max_tokens=500):
+        # Use instance values as defaults if not provided
+        model_name = model_name if model_name is not None else self.model_name
+        temperature = temperature if temperature is not None else self.temperature
+        top_p = top_p if top_p is not None else self.top_p
+        return gemeni_llm.generate_text(user_prompt=user_prompt, 
+                                         model=model_name,temperature=temperature, 
+                                         top_p=top_p, max_tokens=max_tokens)
+
+    def generate_full_response(self, user_prompt,  model_name=None, temperature=None, top_p=None, max_tokens=500):
+        # Use instance values as defaults if not provided
+        model_name = model_name if model_name is not None else self.model_name
+        temperature = temperature if temperature is not None else self.temperature
+        top_p = top_p if top_p is not None else self.top_p
+
+        return gemeni_llm.generate_full_response(user_prompt=user_prompt,
+                                        model=model_name, temperature=temperature, 
+                                        top_p=top_p, max_tokens=max_tokens)
+    
+
+
+    
+
+
+
+
+
+

SimplerLLM-0.1.0/SimplerLLM/langauge/llm_addons.py

@@ -0,0 +1,56 @@
+import time
+from typing import Type
+from pydantic import BaseModel
+from SimplerLLM.langauge.llm import LLM
+
+from SimplerLLM.tools.json_helpers import (
+    extract_json_from_text,
+    convert_json_to_pydantic_model,
+    validate_json_with_pydantic_model,
+    generate_json_example_from_pydantic
+    )
+
+
+def generate_basic_pydantic_json_model(model_class: Type[BaseModel], prompt: str, llm_instance : LLM, max_retries: int = 3, initial_delay: float = 1.0) -> BaseModel:
+    """
+    Generates a model instance based on a given prompt, retrying on validation errors.
+
+    :param model_class: The Pydantic model class to be used for validation and conversion.
+    :param prompt: The fully formatted prompt including the topic.
+    :param llm_instance: Instance of a large language model.
+    :param max_retries: Maximum number of retries on validation errors.
+    :param initial_delay: Initial delay in seconds before the first retry.
+    :return: Tuple containing either (model instance, None) or (None, error message).
+    """
+    for attempt in range(max_retries + 1):
+        try:
+            json_model = generate_json_example_from_pydantic(model_class)
+            optimized_prompt = prompt + f'\n\n.The response should me a structured JSON format that matches the following JSON: {json_model}'
+            ai_response = llm_instance.generate_text(optimized_prompt)
+            
+            if ai_response:
+                json_object = extract_json_from_text(ai_response)
+
+                validated, errors = validate_json_with_pydantic_model(model_class, json_object)
+
+                if not errors:
+                    model_object = convert_json_to_pydantic_model(model_class, json_object[0])
+                    return model_object
+
+        except Exception as e:  # Replace with specific exception if possible
+            return f"Exception occurred: {e}"
+
+        if not ai_response and attempt < max_retries:
+            time.sleep(initial_delay * (2 ** attempt))  # Exponential backoff
+            continue
+        elif errors:
+            return f"Validation failed after {max_retries} retries: {errors}"
+        
+        # Retry logic for validation errors
+        if errors and attempt < max_retries:
+            time.sleep(initial_delay * (2 ** attempt))  # Exponential backoff
+            continue
+        elif errors:
+            return f"Validation failed after {max_retries} retries: {errors}"
+        
+        

SimplerLLM-0.1.0/SimplerLLM/langauge/llm_providers/gemeni_llm.py

@@ -0,0 +1,125 @@
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+import os
+import asyncio
+import time
+
+# Load environment variables
+load_dotenv()
+
+# Constants
+GEMENI_API_KEY = os.getenv('GEMENI_API_KEY')
+if GEMENI_API_KEY is None:
+    raise ValueError("Please set the OPENAI_API_KEY in .env file.")
+
+MAX_RETRIES = os.getenv('MAX_RETRIES')
+if MAX_RETRIES is not None:
+    MAX_RETRIES = int(MAX_RETRIES)
+else:
+    MAX_RETRIES = 3  # Default value
+
+
+RETRY_DELAY = os.getenv('RETRY_DELAY')  
+if RETRY_DELAY is not None:
+    RETRY_DELAY = int(RETRY_DELAY)
+else:
+    RETRY_DELAY = 2  # Default value
+
+
+STREAMING_DELAY = os.getenv('STREAMING_DELAY')
+if STREAMING_DELAY is not None:
+    STREAMING_DELAY = float(RETRY_DELAY)
+else:
+    STREAMING_DELAY = 0.1  # Default value
+
+
+genai.configure(api_key=GEMENI_API_KEY)
+
+
+def generate_text_basic(user_prompt, model):
+    if not user_prompt or not isinstance(user_prompt, str):
+        raise ValueError("user_prompt must be a non-empty string.")
+    
+    if not model or not isinstance(model, str):
+        raise ValueError("model must be a non-empty string.")
+    
+    model = genai.GenerativeModel(model)
+
+    for attempt in range(MAX_RETRIES):
+        try:
+            response = model.generate_content(
+                        user_prompt
+            )
+            return response.text
+
+        except Exception as e:  # Consider catching more specific exceptions
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(RETRY_DELAY * (2**attempt))
+            else:
+                # Log the error or inform the user
+                print(f"Failed to generate response after {MAX_RETRIES} attempts due to: {e}")
+                return None
+
+def generate_text(user_prompt, model, max_tokens=2000, top_p=1.0, temperature=0.7):
+    if not user_prompt or not isinstance(user_prompt, str):
+        raise ValueError("user_prompt must be a non-empty string.")
+    
+    if not model or not isinstance(model, str):
+        raise ValueError("model must be a non-empty string.")
+    
+    model = genai.GenerativeModel(model)
+
+
+    for attempt in range(MAX_RETRIES):
+        try:
+            response = model.generate_content(
+                        user_prompt,
+                generation_config=genai.types.GenerationConfig(
+                    candidate_count=1,
+                    max_output_tokens=max_tokens,
+                    temperature=temperature,top_p=top_p)
+            )
+            return response.text
+
+        except Exception as e:  # Consider catching more specific exceptions
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(RETRY_DELAY * (2**attempt))
+            else:
+                # Log the error or inform the user
+                print(f"Failed to generate response after {MAX_RETRIES} attempts due to: {e}")
+                return None
+
+def generate_full_response(user_prompt, model, max_tokens=2000, top_p=1.0, temperature=0.7):
+    if not user_prompt or not isinstance(user_prompt, str):
+        raise ValueError("user_prompt must be a non-empty string.")
+    
+    if not model or not isinstance(model, str):
+        raise ValueError("model must be a non-empty string.")
+    
+    model = genai.GenerativeModel(model)
+    
+    for attempt in range(MAX_RETRIES):
+        try:
+            response = model.generate_content(
+                        user_prompt,
+                generation_config=genai.types.GenerationConfig(
+                    candidate_count=1,
+                    max_output_tokens=max_tokens,
+                    temperature=temperature,top_p=top_p)
+            )
+            return response
+        
+        except Exception as e:  # Consider catching more specific exceptions
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(RETRY_DELAY * (2**attempt))
+            else:
+                # Log the error or inform the user
+                print(f"Failed to generate response after {MAX_RETRIES} attempts due to: {e}")
+                return None
+
+
+
+
+
+