Update veryfinal.py

veryfinal.py

@@ -26,7 +26,7 @@ class AdvancedRateLimiter:
         self.token_usage = []
         self.consecutive_failures = 0
         
-    async def wait_if_needed(self, estimated_tokens: int = 1000):
+    def wait_if_needed(self, estimated_tokens: int = 1000):
         current_time = time.time()
         
         # Clean old requests (older than 1 minute)
@@ -36,7 +36,7 @@ class AdvancedRateLimiter:
         # Calculate wait time for requests (SILENT)
         if len(self.request_times) >= self.requests_per_minute:
             wait_time = 60 - (current_time - self.request_times[0]) + random.uniform(2, 8)
-            await asyncio.sleep(wait_time)
+            time.sleep(wait_time)  # Changed from asyncio.sleep to time.sleep
         
         # Record this request
         self.request_times.append(current_time)
@@ -52,12 +52,12 @@ class AdvancedRateLimiter:
 # Initialize rate limiters for free tiers
 groq_limiter = AdvancedRateLimiter(requests_per_minute=30, tokens_per_minute=6000)
 gemini_limiter = AdvancedRateLimiter(requests_per_minute=2, tokens_per_minute=32000)
-tavily_limiter = AdvancedRateLimiter(requests_per_minute=50)  # Tavily rate limit
+tavily_limiter = AdvancedRateLimiter(requests_per_minute=50)
 
 # Initialize Tavily client
 tavily_client = TavilyClient(os.getenv("TAVILY_API_KEY"))
 
-# Custom tool functions with rate limiting (SILENT)
+# Custom tool functions - ALL SYNCHRONOUS (SILENT)
 def multiply_tool(a: float, b: float) -> float:
     """Multiply two numbers."""
     return a * b
@@ -76,10 +76,10 @@ def divide_tool(a: float, b: float) -> float:
         raise ValueError("Cannot divide by zero.")
     return a / b
 
-async def tavily_search_tool(query: str) -> str:
-    """Search using Tavily with rate limiting."""
+def tavily_search_tool(query: str) -> str:
+    """Search using Tavily with rate limiting - SYNCHRONOUS."""
     try:
-        await tavily_limiter.wait_if_needed()
+        tavily_limiter.wait_if_needed()
         response = tavily_client.search(
             query=query,
             max_results=3,
@@ -97,20 +97,20 @@ async def tavily_search_tool(query: str) -> str:
     except Exception as e:
         return f"Tavily search failed: {str(e)}"
 
-async def wiki_search_tool(query: str) -> str:
-    """Search Wikipedia with rate limiting."""
+def wiki_search_tool(query: str) -> str:
+    """Search Wikipedia with rate limiting - SYNCHRONOUS."""
     try:
-        await asyncio.sleep(random.uniform(1, 3))
+        time.sleep(random.uniform(1, 3))  # Changed from asyncio.sleep
         loader = WikipediaLoader(query=query, load_max_docs=1)
         data = loader.load()
         return "\n\n---\n\n".join([doc.page_content[:1000] for doc in data])
     except Exception as e:
         return f"Wikipedia search failed: {str(e)}"
 
-async def arxiv_search_tool(query: str) -> str:
-    """Search ArXiv with rate limiting."""
+def arxiv_search_tool(query: str) -> str:
+    """Search ArXiv with rate limiting - SYNCHRONOUS."""
     try:
-        await asyncio.sleep(random.uniform(1, 4))
+        time.sleep(random.uniform(1, 4))  # Changed from asyncio.sleep
         search_docs = ArxivLoader(query=query, load_max_docs=2).load()
         return "\n\n---\n\n".join([doc.page_content[:800] for doc in search_docs])
     except Exception as e:
@@ -148,7 +148,7 @@ def create_agno_agents():
             api_key=os.getenv("GOOGLE_API_KEY"),
             temperature=0
         ),
-        tools=[tavily_search_tool, wiki_search_tool, arxiv_search_tool],  # Using Tavily instead of DuckDuckGo
+        tools=[tavily_search_tool, wiki_search_tool, arxiv_search_tool],  # All synchronous now
         instructions=[
             "You are a research specialist with access to multiple search tools.",
             "Use Tavily search for current web information, Wikipedia for encyclopedic content, and ArXiv for academic papers.",
@@ -168,7 +168,7 @@ def create_agno_agents():
             api_key=os.getenv("GROQ_API_KEY"), 
             temperature=0
         ),
-        tools=[tavily_search_tool, wiki_search_tool],  # Using Tavily instead of DuckDuckGo
+        tools=[tavily_search_tool, wiki_search_tool],  # All synchronous now
         instructions=[
             "You are the main coordinator agent.",
             "Analyze queries and provide comprehensive responses.",
@@ -185,7 +185,7 @@ def create_agno_agents():
         "coordinator": coordinator_agent
     }
 
-# Main Agno multi-agent system (SILENT)
+# Main Agno multi-agent system (SIMPLIFIED - NO ASYNC)
 class AgnoMultiAgentSystem:
     """Agno multi-agent system with comprehensive rate limiting"""
     
@@ -194,8 +194,8 @@ class AgnoMultiAgentSystem:
         self.request_count = 0
         self.last_request_time = time.time()
     
-    async def process_query(self, query: str, max_retries: int = 5) -> str:
-        """Process query using Agno agents with advanced rate limiting (SILENT)"""
+    def process_query(self, query: str, max_retries: int = 5) -> str:
+        """Process query using Agno agents with rate limiting (SYNCHRONOUS)"""
         
         # Global rate limiting (SILENT)
         current_time = time.time()
@@ -207,7 +207,7 @@ class AgnoMultiAgentSystem:
         
         # Add delay between requests (SILENT)
         if self.request_count > 1:
-            await asyncio.sleep(random.uniform(3, 10))
+            time.sleep(random.uniform(3, 10))  # Changed from asyncio.sleep
         
         for attempt in range(max_retries):
             try:
@@ -228,7 +228,7 @@ class AgnoMultiAgentSystem:
                 
                 if any(keyword in error_msg for keyword in ['rate limit', '429', 'quota', 'too many requests']):
                     wait_time = (2 ** attempt) + random.uniform(15, 45)
-                    await asyncio.sleep(wait_time)
+                    time.sleep(wait_time)  # Changed from asyncio.sleep
                     continue
                 
                 elif attempt == max_retries - 1:
@@ -239,28 +239,15 @@ class AgnoMultiAgentSystem:
                 
                 else:
                     wait_time = (2 ** attempt) + random.uniform(2, 8)
-                    await asyncio.sleep(wait_time)
+                    time.sleep(wait_time)  # Changed from asyncio.sleep
         
         return "Maximum retries exceeded. Please try again later."
 
-# SILENT main function
-async def main_async(query: str) -> str:
-    """Async main function compatible with Jupyter notebooks (SILENT)"""
-    agno_system = AgnoMultiAgentSystem()
-    return await agno_system.process_query(query)
-
+# SIMPLIFIED main function (NO ASYNC)
 def main(query: str) -> str:
-    """Main function using Agno multi-agent system (SILENT)"""
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            import nest_asyncio
-            nest_asyncio.apply()
-            return asyncio.run(main_async(query))
-        else:
-            return asyncio.run(main_async(query))
-    except RuntimeError:
-        return asyncio.run(main_async(query))
+    """Main function using Agno multi-agent system (SYNCHRONOUS)"""
+    agno_system = AgnoMultiAgentSystem()
+    return agno_system.process_query(query)
 
 def get_final_answer(query: str) -> str:
     """Extract only the FINAL ANSWER from the response"""
@@ -272,12 +259,7 @@ def get_final_answer(query: str) -> str:
     else:
         return full_response.strip()
 
-# For Jupyter notebooks
-async def run_query(query: str) -> str:
-    """Direct async function for Jupyter notebooks (SILENT)"""
-    return await main_async(query)
-
 if __name__ == "__main__":
-    # Test the Agno system with Tavily - CLEAN OUTPUT ONLY
+    # Test the Agno system - CLEAN OUTPUT ONLY
     result = get_final_answer("What are the names of the US presidents who were assassinated?")
     print(result)