Update app.py

app.py

@@ -1,28 +1,35 @@
 from fastapi import FastAPI, HTTPException, Query
-from fastapi.responses import JSONResponse
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import StreamingResponse
-from webscout import WEBS, YTTranscriber, LLM, fastai
-from stream import fastai_stream
-from typing import Optional, List, Dict, Union
+from fastapi.responses import JSONResponse, StreamingResponse
+from webscout import WEBS, YTTranscriber, LLM
+from typing import Optional, List, Dict
 from fastapi.encoders import jsonable_encoder
 from bs4 import BeautifulSoup
 import requests
-import urllib.parse
-import asyncio
 import aiohttp
+import asyncio
 import threading
 import json
-import os
-import time
-from huggingface_hub import HfApi
 from huggingface_hub import InferenceClient
 from PIL import Image
 import io
-import ast
+from easygoogletranslate import EasyGoogleTranslate
+
+from pydantic import BaseModel
 
 app = FastAPI()
 
+# Define Pydantic models for request payloads
+class ChatRequest(BaseModel):
+    q: str
+    model: str = "gpt-4o-mini"
+    history: List[Dict[str, str]] = []
+    proxy: Optional[str] = None
+
+class AIRequest(BaseModel):
+    user: str
+    model: str = "llama3-70b"
+    system: str = "Answer as concisely as possible."
+
 @app.get("/")
 async def root():
     return {"message": "API documentation can be found at /docs"}
@@ -39,11 +46,11 @@ async def search(
     safesearch: str = "moderate",
     region: str = "wt-wt",
     backend: str = "api",
-    proxy: Optional[str] = None  # Add proxy parameter here
+    proxy: Optional[str] = None
 ):
     """Perform a text search."""
     try:
-        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+        with WEBS(proxy=proxy) as webs:
             results = webs.text(
                 keywords=q,
                 region=region,
@@ -68,11 +75,11 @@ async def images(
     type_image: Optional[str] = None,
     layout: Optional[str] = None,
     license_image: Optional[str] = None,
-    proxy: Optional[str] = None # Add proxy parameter here
+    proxy: Optional[str] = None
 ):
     """Perform an image search."""
     try:
-        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+        with WEBS(proxy=proxy) as webs:
             results = webs.images(
                 keywords=q,
                 region=region,
@@ -99,11 +106,11 @@ async def videos(
     resolution: Optional[str] = None,
     duration: Optional[str] = None,
     license_videos: Optional[str] = None,
-    proxy: Optional[str] = None # Add proxy parameter here
+    proxy: Optional[str] = None
 ):
     """Perform a video search."""
     try:
-        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+        with WEBS(proxy=proxy) as webs:
             results = webs.videos(
                 keywords=q,
                 region=region,
@@ -125,11 +132,11 @@ async def news(
     safesearch: str = "moderate",
     region: str = "wt-wt",
     timelimit: Optional[str] = None,
-    proxy: Optional[str] = None  # Add proxy parameter here
+    proxy: Optional[str] = None
 ):
     """Perform a news search."""
     try:
-        with WEBS(proxy=proxy) as webs:  # Pass proxy to WEBS instance
+        with WEBS(proxy=proxy) as webs:
             results = webs.news(
                 keywords=q,
                 region=region,
@@ -141,61 +148,6 @@ async def news(
     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,
-    message: str,
-    system_prompt: str = Query(None, description="Optional custom system prompt")
-):
-    """Interact with a specified large language model with an optional system prompt."""
-    try:
-        messages = [{"role": "user", "content": message}]
-        if system_prompt:
-            messages.insert(0, {"role": "system", "content": system_prompt})  # Add system message at the beginning
-
-        llm = LLM(model=model)
-        response = llm.chat(messages=messages)
-        return JSONResponse(content={"response": response})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error during LLM chat: {e}")
-
-@app.get("/api/fastAI")
-async def fast_ai(user: str, model: str = "llama3-70b", system: str = "Answer as concisely as possible."):
-    """Get a response from the Snova AI service."""
-    try:
-        response = await asyncio.to_thread(fastai, user, model, system)
-        return JSONResponse(content={"response": response})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error during Snova AI request: {e}")
-
-from pydantic import BaseModel
-import asyncio
-
-app = FastAPI()
-
-# Define a Pydantic model for the request payload
-class FastAIRequest(BaseModel):
-    user: str
-    model: str = "llama3-70b"
-    system: str = "Answer as concisely as possible."
-
-@app.post("/api/fastAI-post")
-async def fast_ai(request: FastAIRequest):
-    """Get a response from the Snova AI service."""
-    try:
-        response = await asyncio.to_thread(fastai, request.user, request.model, request.system)
-        return JSONResponse(content={"response": response})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error during Snova AI request: {e}")
-
-@app.get("/api/streaming-fastAI")
-async def fast_ai(user: str, model: str = "llama3-8b", system: str = "Answer as concisely as possible."):
-    """Get a streaming response from the Snova AI service."""
-    try:
-        return StreamingResponse(fastai_stream(user, model, system), media_type="text/event-stream")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error during Snova AI request: {e}")
-
 @app.get("/api/answers")
 async def answers(q: str, proxy: Optional[str] = None):
     """Get instant answers for a query."""
@@ -206,39 +158,85 @@ async def answers(q: str, proxy: Optional[str] = None):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting instant answers: {e}")
 
+@app.get("/api/maps")
+async def maps(
+    q: str,
+    place: Optional[str] = None,
+    street: Optional[str] = None,
+    city: Optional[str] = None,
+    county: Optional[str] = None,
+    state: Optional[str] = None,
+    country: Optional[str] = None,
+    postalcode: Optional[str] = None,
+    latitude: Optional[str] = None,
+    longitude: Optional[str] = None,
+    radius: int = 0,
+    max_results: int = 10,
+    proxy: Optional[str] = None
+):
+    """Perform a maps search."""
+    try:
+        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:
+        raise HTTPException(status_code=500, detail=f"Error during maps search: {e}")
+
 @app.get("/api/chat")
 async def chat(
     q: str,
     model: str = "gpt-4o-mini",
     proxy: Optional[str] = None
 ):
-    """Perform a text search."""
+    """Interact with a specified large language model."""
     try:
         with WEBS(proxy=proxy) as webs:
-            results = webs.chat(chat_messages=[{"role": "user", "content": q}], model=model)
+            results = webs.chat(keywords=q, model=model)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting chat results: {e}")
 
-# Define a Pydantic model for the request payload
-class ChatRequest(BaseModel):
-    q: str
-    model: str = "gpt-4o-mini"
-    history: List[Dict[str, str]] = []
-    proxy: Optional[str] = None
-
 @app.post("/api/chat-post")
-async def chat(request: ChatRequest):
-    """Perform a text search."""
+async def chat_post(request: ChatRequest):
+    """Interact with a specified large language model with chat history."""
     try:
         with WEBS(proxy=request.proxy) as webs:
-            chat_messages = request.history
-            chat_messages.append({"role": "user", "content": request.q})
-            results = webs.chat(chat_messages = chat_messages, model=request.model)
+            results = webs.chat(keywords=request.q, model=request.model, chat_messages=request.history)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting chat results: {e}")
 
+@app.get("/api/llm")
+async def llm_chat(
+    model: str,
+    message: str,
+    system_prompt: str = Query(None, description="Optional custom system prompt")
+):
+    """Interact with a specified large language model with an optional system prompt."""
+    try:
+        messages = [{"role": "user", "content": message}]
+        if system_prompt:
+            messages.insert(0, {"role": "system", "content": system_prompt}) 
+
+        llm = LLM(model=model)
+        response = llm.chat(messages=messages)
+        return JSONResponse(content={"response": response})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during LLM chat: {e}")
+
+@app.post("/api/ai-post") 
+async def ai_post(request: AIRequest):
+    """Interact with a specified large language model (using AIRequest model)."""
+    try:
+        llm = LLM(model=request.model)
+        response = llm.chat(messages=[
+            {"role": "system", "content": request.system},
+            {"role": "user", "content": request.user}
+        ])
+        return JSONResponse(content={"response": response})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during AI request: {e}")
+
 def extract_text_from_webpage(html_content):
     """Extracts visible text from HTML content using BeautifulSoup."""
     soup = BeautifulSoup(html_content, "html.parser")
@@ -379,7 +377,7 @@ def web_search_and_extract_threading(
 @app.get("/api/adv_web_search")
 async def adv_web_search(
     q: str,
-    model: str = "llama3-8b",
+    model: str = "gpt-4o-mini",  # Use webs.chat by default
     max_results: int = 3,
     timelimit: Optional[str] = None,
     safesearch: str = "moderate",
@@ -390,7 +388,7 @@ async def adv_web_search(
     proxy: Optional[str] = None
 ):
     """
-    Combines web search, web extraction, and FastAI chat for advanced search.
+    Combines web search, web extraction, and chat model for advanced search.
     """
     try:
         with WEBS(proxy=proxy) as webs:
@@ -408,7 +406,7 @@ async def adv_web_search(
                 if result['text']:
                     extracted_text += f"## Content from: {result['link']}\n\n{result['text']}\n\n"
 
-        # 3. Construct the prompt for FastAI
+        # 3. Construct the prompt for the chat model
         ai_prompt = (
             f"User Query: {q}\n\n"
             f"Please provide a detailed and accurate answer to the user's query. Include relevant information extracted from the search results below. Ensure to cite sources by providing links to the original content where applicable. Format your response as follows:\n\n"
@@ -418,11 +416,9 @@ async def adv_web_search(
             f"Search Results:\n{extracted_text}"
         )
 
-        # 4. Get the FastAI's response using FastAI service
-        try:
-            response = await asyncio.to_thread(fastai, ai_prompt, model=model, system=system_prompt)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Error during FastAI request: {e}")
+        # 4. Get the chat model's response using webs.chat 
+        with WEBS(proxy=proxy) as webs:
+            response = webs.chat(keywords=ai_prompt, model=model)
 
         # 5. Return the results
         return JSONResponse(content={"response": response})
@@ -485,47 +481,23 @@ async def ask_website(url: str, question: str, model: str = "llama-3-70b", proxy
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during question answering: {e}")
 
+# Stable Diffusion client
 client_sd3 = InferenceClient("stabilityai/stable-diffusion-3-medium-diffusers")
 
 @app.get("/api/sd3")
-def sd3(prompt :str = "",
-        steps: int = 20,
-        width: int = 1000,
-        height: int = 1000
-       ):
+def sd3(prompt: str = "", steps: int = 20, width: int = 1000, height: int = 1000):
     try:
-        image = client_sd3.text_to_image(prompt = f"{prompt}, hd, high quality, 4k, masterpiece",
-                num_inference_steps = steps,
-                width = width, height = height )
+        image = client_sd3.text_to_image(
+            prompt=f"{prompt}, hd, high quality, 4k, masterpiece",
+            num_inference_steps=steps,
+            width=width,
+            height=height
+        )
         image = Image.open(io.BytesIO(image))
-        return image
+        return image 
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error during image generation: {e}")
 
-@app.get("/api/maps")
-async def maps(
-    q: str,
-    place: Optional[str] = None,
-    street: Optional[str] = None,
-    city: Optional[str] = None,
-    county: Optional[str] = None,
-    state: Optional[str] = None,
-    country: Optional[str] = None,
-    postalcode: Optional[str] = None,
-    latitude: Optional[str] = None,
-    longitude: Optional[str] = None,
-    radius: int = 0,
-    max_results: int = 10,
-    proxy: Optional[str] = None
-):
-    """Perform a maps search."""
-    try:
-        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:
-        raise HTTPException(status_code=500, detail=f"Error during maps search: {e}")
-
 @app.get("/api/translate")
 async def translate(
     q: str,
@@ -541,16 +513,14 @@ async def translate(
     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
-)
+            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:
@@ -570,7 +540,6 @@ async def youtube_transcript(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting YouTube transcript: {e}")
 
-import requests
 @app.get("/weather/json/{location}")
 def get_weather_json(location: str):
     url = f"https://wttr.in/{location}?format=j1"
@@ -589,29 +558,6 @@ def get_ascii_weather(location: str):
     else:
         return {"error": f"Unable to fetch weather data. Status code: {response.status_code}"}
 
-# Run the API server if this script is executed
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8083)
-
-# def main():
-#     # Retrieve the space ID and token from environment variables
-#     space_id = os.getenv("SPACE_ID")
-#     token = os.getenv("HF_TOKEN")
-
-#     # Initialize the HfApi with the retrieved token
-#     api = HfApi(token=token)
-
-#     while True:
-#         try:
-#             # Restart the space
-#             api.restart_space(space_id, factory_reboot=False)
-#             print(f"Successfully restarted the space: {space_id}")
-#         except Exception as e:
-#             print(f"Error restarting the space: {e}")
-
-#         # Wait for 10 minutes before restarting again
-#         time.sleep(600)  # Sleep for 600 seconds (10 minutes)
-
-# if __name__ == "__main__":
-#     main()
+    uvicorn.run(app, host="0.0.0.0", port=8083)