Merge pull request #10 from rishiraj/no-llm-dep

remove llm provider dependency

Author: rishiraj

README.md

@@ -123,30 +123,38 @@ fr.compare(url)
 
 ### Generating Text with LLMs
 
-FireRequests supports generating responses from LLMs like OpenAI’s and Google’s generative models in parallel batches. This currently doesn't work in Colab.
+FireRequests allows you to run LLM API calls (like OpenAI or Google) in parallel batches using a decorator. This keeps the library lightweight and lets users supply their own logic for calling APIs. This approach currently doesn't work in Colab.
 
 ```python
 from firerequests import FireRequests
 
 # Initialize FireRequests
 fr = FireRequests()
 
-# Set parameters
-provider = "openai"
-model = "gpt-4o-mini"
-system_prompt = "Provide concise answers."
-user_prompts = ["What is AI?", "Explain quantum computing.", "What is Bitcoin?", "Explain neural networks."]
-parallel_requests = 2
-
-# Generate responses
-responses = fr.generate(
-    provider=provider,
-    model=model,
-    system_prompt=system_prompt,
-    user_prompts=user_prompts,
-    parallel_requests=parallel_requests
-)
-
+# Use the decorator to define your own prompt function
+@fr.op(max_reqs=2, prompts=[
+    "What is AI?",
+    "Explain quantum computing.",
+    "What is Bitcoin?",
+    "Explain neural networks."
+])
+def generate(system: str = "Provide concise answers.", prompt: str = ""):
+    # You can use OpenAI, Google, or any other LLM API here
+    from openai import OpenAI
+    import os
+
+    client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return response.choices[0].message.content
+
+# Call your decorated function
+responses = generate()
 print(responses)
 ```
 

firerequests/main.py

@@ -286,86 +286,38 @@ def compare(self, url: str, filename: Optional[str] = None):
         except Exception as e:
             print(f"Error in compare: {e}")
 
-    def call_openai_sync(self, model: str, system_prompt: str, user_prompt: str) -> str:
-        from openai import OpenAI
-        client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
-        completion = client.chat.completions.create(
-            model=model,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt}
-            ]
-        )
-        return completion.choices[0].message.content
-
-    async def call_openai(self, model: str, system_prompt: str, user_prompt: str) -> str:
-        return await asyncio.to_thread(self.call_openai_sync, model, system_prompt, user_prompt)
-
-    def call_google_sync(self, model: str, system_prompt: str, user_prompt: str) -> str:
-        import google.generativeai as genai
-        genai.configure(api_key=os.environ["GEMINI_API_KEY"])
-
-        generation_config = {
-            "temperature": 1,
-            "top_p": 0.95,
-            "top_k": 40,
-            "max_output_tokens": 8192,
-            "response_mime_type": "text/plain",
-        }
-
-        model_instance = genai.GenerativeModel(
-            model_name=model,
-            generation_config=generation_config,
-            system_instruction=system_prompt,
-        )
-
-        chat_session = model_instance.start_chat(history=[])
-        response = chat_session.send_message(user_prompt)
-        return response.text
-
-    async def call_google(self, model: str, system_prompt: str, user_prompt: str) -> str:
-        return await asyncio.to_thread(self.call_google_sync, model, system_prompt, user_prompt)
-
-    async def generate_batch(
-        self, provider: str, model: str, system_prompt: str, user_prompts: List[str]
-    ) -> List[str]:
-        tasks = []
-        for user_prompt in user_prompts:
-            if provider.lower() == "openai":
-                tasks.append(self.call_openai(model, system_prompt, user_prompt))
-            elif provider.lower() == "google":
-                tasks.append(self.call_google(model, system_prompt, user_prompt))
-            else:
-                raise ValueError("Unsupported provider. Choose either 'openai' or 'google'.")
-        
-        responses = await asyncio.gather(*tasks)
-        return responses
-
-    def generate(
-        self, provider: str, model: str, system_prompt: str, user_prompts: List[str], parallel_requests: int = 10
-    ) -> List[str]:
+    def op(self, max_reqs: int = 10, prompts: Optional[List[str]] = None):
         """
-        Generates responses for the given list of user prompts in parallel batches.
+        Decorator to parallelize a user-defined prompt function over a list of prompts.
 
         Args:
-            provider (str): The API provider to use, either "openai" or "google".
-            model (str): The model to use for generating responses.
-            system_prompt (str): The system message prompt to include in each request.
-            user_prompts (List[str]): List of user messages for generation.
-            parallel_requests (int): Number of parallel requests to make.
+            max_reqs (int): Maximum number of parallel tasks.
+            prompts (List[str]): Prompts to process.
 
         Returns:
-            List[str]: List of generated responses corresponding to each user prompt.
+            Decorated function executed in parallel using asyncio.
         """
-        async def generate_all():
-            all_responses = []
-            for i in range(0, len(user_prompts), parallel_requests):
-                batch_prompts = user_prompts[i:i + parallel_requests]
-                batch_responses = await self.generate_batch(provider, model, system_prompt, batch_prompts)
-                all_responses.extend(batch_responses)
-            return all_responses
-
-        return self.loop.run_until_complete(generate_all())
+        def decorator(func):
+            async def run_batch(prompts_batch):
+                tasks = [asyncio.to_thread(func, prompt=prompt) for prompt in prompts_batch]
+                return await asyncio.gather(*tasks)
+
+            def wrapper(*args, **kwargs):
+                if prompts is None:
+                    raise ValueError("You must pass a list of prompts to the decorator.")
+                results = []
+
+                async def run_all():
+                    for i in range(0, len(prompts), max_reqs):
+                        batch = prompts[i:i + max_reqs]
+                        batch_results = await run_batch(batch)
+                        results.extend(batch_results)
+                    return results
+
+                return self.loop.run_until_complete(run_all())
+
+            return wrapper
+        return decorator
 
 def main():
     fire.Fire(FireRequests)

requirements.txt

@@ -3,6 +3,4 @@ aiofiles
 requests
 nest_asyncio
 tqdm
-fire
-google-generativeai
-openai
+fire