Update app.py

app.py

@@ -9,7 +9,6 @@ import urllib.parse
 import asyncio
 import aiohttp
 import threading
-from typing import List
 
 app = FastAPI()
 
@@ -28,12 +27,20 @@ async def search(
     timelimit: Optional[str] = None,
     safesearch: str = "moderate",
     region: str = "wt-wt",
-    backend: str = "api"
+    backend: str = "api",
+    proxy: Optional[str] = None  # Add proxy parameter here
 ):
     """Perform a text search."""
     try:
-        with WEBS() as webs:
-            results = webs.text(keywords=q, region=region, safesearch=safesearch, timelimit=timelimit, backend=backend, max_results=max_results)
+        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+            results = webs.text(
+                keywords=q,
+                region=region,
+                safesearch=safesearch,
+                timelimit=timelimit,
+                backend=backend,
+                max_results=max_results,
+            )
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during search: {e}")
@@ -49,12 +56,24 @@ async def images(
     color: Optional[str] = None,
     type_image: Optional[str] = None,
     layout: Optional[str] = None,
-    license_image: Optional[str] = None
+    license_image: Optional[str] = None,
+    proxy: Optional[str] = None # Add proxy parameter here
 ):
     """Perform an image search."""
     try:
-        with WEBS() as webs:
-            results = webs.images(keywords=q, region=region, safesearch=safesearch, timelimit=timelimit, size=size, color=color, type_image=type_image, layout=layout, license_image=license_image, max_results=max_results)
+        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+            results = webs.images(
+                keywords=q,
+                region=region,
+                safesearch=safesearch,
+                timelimit=timelimit,
+                size=size,
+                color=color,
+                type_image=type_image,
+                layout=layout,
+                license_image=license_image,
+                max_results=max_results,
+            )
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during image search: {e}")
@@ -68,32 +87,51 @@ async def videos(
     timelimit: Optional[str] = None,
     resolution: Optional[str] = None,
     duration: Optional[str] = None,
-    license_videos: Optional[str] = None
+    license_videos: Optional[str] = None,
+    proxy: Optional[str] = None # Add proxy parameter here
 ):
     """Perform a video search."""
     try:
-        with WEBS() as webs:
-            results = webs.videos(keywords=q, region=region, safesearch=safesearch, timelimit=timelimit, resolution=resolution, duration=duration, license_videos=license_videos, max_results=max_results)
+        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+            results = webs.videos(
+                keywords=q,
+                region=region,
+                safesearch=safesearch,
+                timelimit=timelimit,
+                resolution=resolution,
+                duration=duration,
+                license_videos=license_videos,
+                max_results=max_results,
+            )
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during video search: {e}")
 
+
 @app.get("/api/news")
 async def news(
     q: str,
     max_results: int = 10,
     safesearch: str = "moderate",
     region: str = "wt-wt",
-    timelimit: Optional[str] = None
+    timelimit: Optional[str] = None,
+    proxy: Optional[str] = None  # Add proxy parameter here
 ):
     """Perform a news search."""
     try:
-        with WEBS() as webs:
-            results = webs.news(keywords=q, region=region, safesearch=safesearch, timelimit=timelimit, max_results=max_results)
+        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+            results = webs.news(
+                keywords=q,
+                region=region,
+                safesearch=safesearch,
+                timelimit=timelimit,
+                max_results=max_results
+            )
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during news search: {e}")
 
+
 @app.get("/api/llm")
 async def llm_chat(
     model: str,
@@ -114,20 +152,20 @@ async def llm_chat(
 
 
 @app.get("/api/answers")
-async def answers(q: str):
+async def answers(q: str, proxy: Optional[str] = None):
     """Get instant answers for a query."""
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             results = webs.answers(keywords=q)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting instant answers: {e}")
 
 @app.get("/api/suggestions")
-async def suggestions(q: str, region: str = "wt-wt"):
+async def suggestions(q: str, region: str = "wt-wt", proxy: Optional[str] = None):
     """Get search suggestions for a query."""
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             results = webs.suggestions(keywords=q, region=region)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
@@ -136,11 +174,12 @@ async def suggestions(q: str, region: str = "wt-wt"):
 @app.get("/api/chat")
 async def chat(
     q: str,
-    model: str = "gpt-3.5"
+    model: str = "gpt-3.5",
+    proxy: Optional[str] = None
 ):
     """Perform a text search."""
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             results = webs.chat(keywords=q, model=model)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
@@ -156,11 +195,12 @@ def extract_text_from_webpage(html_content):
     visible_text = soup.get_text(strip=True)
     return visible_text
 
-async def fetch_and_extract(url, max_chars):
+async def fetch_and_extract(url, max_chars, proxy: Optional[str] = None):
     """Fetches a URL and extracts text asynchronously."""
+    
     async with aiohttp.ClientSession() as session:
         try:
-            async with session.get(url, headers={"User-Agent": "Mozilla/5.0"}) as response:
+            async with session.get(url, headers={"User-Agent": "Mozilla/5.0"}, proxy=proxy) as response:
                 response.raise_for_status()
                 html_content = await response.text()
                 visible_text = extract_text_from_webpage(html_content)
@@ -175,10 +215,11 @@ async def fetch_and_extract(url, max_chars):
 async def web_extract(
     url: str,
     max_chars: int = 12000,  # Adjust based on token limit
+    proxy: Optional[str] = None
 ):
     """Extracts text from a given URL."""
     try:
-        result = await fetch_and_extract(url, max_chars)
+        result = await fetch_and_extract(url, max_chars, proxy)
         return {"url": url, "text": result["text"]}
     except requests.exceptions.RequestException as e:
         raise HTTPException(status_code=500, detail=f"Error fetching or processing URL: {e}")
@@ -192,19 +233,20 @@ async def web_search_and_extract(
     region: str = "wt-wt",
     backend: str = "html",
     max_chars: int = 6000,
-    extract_only: bool = True
+    extract_only: bool = True,
+    proxy: Optional[str] = None
 ):
     """
     Searches using WEBS, extracts text from the top results, and returns both.
     """
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             # Perform WEBS search
             search_results = webs.text(keywords=q, region=region, safesearch=safesearch,
                                      timelimit=timelimit, backend=backend, max_results=max_results)
 
             # Extract text from each result's link asynchronously
-            tasks = [fetch_and_extract(result['href'], max_chars) for result in search_results if 'href' in result]
+            tasks = [fetch_and_extract(result['href'], max_chars, proxy) for result in search_results if 'href' in result]
             extracted_results = await asyncio.gather(*tasks)
 
             if extract_only:
@@ -224,10 +266,11 @@ def extract_text_from_webpage2(html_content):
     visible_text = soup.get_text(strip=True)
     return visible_text
 
-def fetch_and_extract2(url, max_chars):
+def fetch_and_extract2(url, max_chars, proxy: Optional[str] = None):
     """Fetches a URL and extracts text using threading."""
+    proxies = {'http': proxy, 'https': proxy} if proxy else None
     try:
-        response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
+        response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, proxies=proxies)
         response.raise_for_status()
         html_content = response.text
         visible_text = extract_text_from_webpage2(html_content)
@@ -247,13 +290,14 @@ def web_search_and_extract_threading(
     region: str = "wt-wt",
     backend: str = "html",
     max_chars: int = 6000,
-    extract_only: bool = True
+    extract_only: bool = True,
+    proxy: Optional[str] = None
 ):
     """
     Searches using WEBS, extracts text from the top results using threading, and returns both.
     """
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             # Perform WEBS search
             search_results = webs.text(keywords=q, region=region, safesearch=safesearch,
                                      timelimit=timelimit, backend=backend, max_results=max_results)
@@ -263,7 +307,7 @@ def web_search_and_extract_threading(
             threads = []
             for result in search_results:
                 if 'href' in result:
-                    thread = threading.Thread(target=lambda: extracted_results.append(fetch_and_extract2(result['href'], max_chars)))
+                    thread = threading.Thread(target=lambda: extracted_results.append(fetch_and_extract2(result['href'], max_chars, proxy)))
                     threads.append(thread)
                     thread.start()
 
@@ -289,13 +333,14 @@ async def adv_web_search(
     region: str = "wt-wt",
     backend: str = "html",
     max_chars: int = 6000,  
-    system_prompt: str = "You are Most Advanced and Powerful Ai chatbot, User ask you questions and you have to answer that, You are also provided with Google Search Results, To increase your accuracy and providing real time data. Your task is to answer in best way to user."
+    system_prompt: str = "You are Most Advanced and Powerful Ai chatbot, User ask you questions and you have to answer that, You are also provided with Google Search Results, To increase your accuracy and providing real time data. Your task is to answer in best way to user.",
+    proxy: Optional[str] = None
 ):
     """
     Combines web search, web extraction, and LLM chat for advanced search.
     """
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             # 1. Perform the web search
             search_results = webs.text(keywords=q, region=region, 
                                      safesearch=safesearch,
@@ -304,7 +349,7 @@ async def adv_web_search(
 
             # 2. Extract text from top search result URLs asynchronously 
             extracted_text = ""
-            tasks = [fetch_and_extract(result['href'], max_chars) for result in search_results if 'href' in result]
+            tasks = [fetch_and_extract(result['href'], max_chars, proxy) for result in search_results if 'href' in result]
             extracted_results = await asyncio.gather(*tasks)
             for result in extracted_results:
                 if result['text']:
@@ -329,18 +374,19 @@ async def adv_web_search(
 
         
 @app.get("/api/website_summarizer")
-async def website_summarizer(url: str):
+async def website_summarizer(url: str, proxy: Optional[str] = None):
     """Summarizes the content of a given URL using a chat model."""
     try:
         # Extract text from the given URL
-        response = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"})
+        proxies = {'http': proxy, 'https': proxy} if proxy else None
+        response = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"}, proxies=proxies)
         response.raise_for_status()
         visible_text = extract_text_from_webpage(response.text)
         if len(visible_text) > 7500:  # Adjust max_chars based on your needs
             visible_text = visible_text[:7500] + "..."
 
         # Use chat model to summarize the extracted text
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             summary_prompt = f"Summarize this in detail in Paragraph: {visible_text}"
             summary_result = webs.chat(keywords=summary_prompt, model="gpt-3.5")
 
@@ -353,13 +399,14 @@ async def website_summarizer(url: str):
         raise HTTPException(status_code=500, detail=f"Error during summarization: {e}")
         
 @app.get("/api/ask_website")
-async def ask_website(url: str, question: str, model: str = "llama-3-70b"):
+async def ask_website(url: str, question: str, model: str = "llama-3-70b", proxy: Optional[str] = None):
     """
     Asks a question about the content of a given website.
     """
     try:
         # Extract text from the given URL
-        response = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"})
+        proxies = {'http': proxy, 'https': proxy} if proxy else None
+        response = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"}, proxies=proxies)
         response.raise_for_status()
         visible_text = extract_text_from_webpage(response.text)
         if len(visible_text) > 7500:  # Adjust max_chars based on your needs
@@ -369,7 +416,7 @@ async def ask_website(url: str, question: str, model: str = "llama-3-70b"):
         prompt = f"Based on the following text, answer this question in Paragraph: [QUESTION] {question} [TEXT] {visible_text}"
 
         # Use chat model to get the answer
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             answer_result = webs.chat(keywords=prompt, model=model)
 
         # Return the answer result
@@ -393,11 +440,12 @@ async def maps(
     latitude: Optional[str] = None,
     longitude: Optional[str] = None,
     radius: int = 0,
-    max_results: int = 10
+    max_results: int = 10,
+    proxy: Optional[str] = None
 ):
     """Perform a maps search."""
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             results = webs.maps(keywords=q, place=place, street=street, city=city, county=county, state=state, country=country, postalcode=postalcode, latitude=latitude, longitude=longitude, radius=radius, max_results=max_results)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
@@ -407,26 +455,44 @@ async def maps(
 async def translate(
     q: str,
     from_: Optional[str] = None,
-    to: str = "en"
+    to: str = "en",
+    proxy: Optional[str] = None
 ):
     """Translate text."""
     try:
-        with WEBS() as webs:
+        with WEBS(proxy=proxy) as webs:
             results = webs.translate(keywords=q, from_=from_, to=to)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during translation: {e}")
 
+from easygoogletranslate import EasyGoogleTranslate
+
+@app.get("/api/google_translate")
+def google_translate(q: str, from_: Optional[str] = 'auto', to: str = "en"):
+    try:
+        translator = EasyGoogleTranslate(
+    source_language=from_,
+    target_language=to,
+    timeout=10
+)
+        result = translator.translate(q)
+        return JSONResponse(content=jsonable_encoder({"detected_language": from_ , "original": q , "translated": result}))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during translation: {e}")
+    
+
 @app.get("/api/youtube/transcript")
 async def youtube_transcript(
     video_id: str,
     languages: str = "en",
-    preserve_formatting: bool = False
+    preserve_formatting: bool = False,
+    proxy: Optional[str] = None  # Add proxy parameter
 ):
     """Get the transcript of a YouTube video."""
     try:
         languages_list = languages.split(",")
-        transcript = transcriber.get_transcript(video_id, languages=languages_list, preserve_formatting=preserve_formatting)
+        transcript = transcriber.get_transcript(video_id, languages=languages_list, preserve_formatting=preserve_formatting, proxies=proxy)
         return JSONResponse(content=jsonable_encoder(transcript))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting YouTube transcript: {e}")