Update app.py

app.py

@@ -1,176 +1,160 @@
-from fastapi import FastAPI, Request, HTTPException
+from fastapi import FastAPI, HTTPException
 from fastapi.responses import JSONResponse
 from webscout import WEBS, transcriber
 
-# from webscout.websx_search import WEBSX
-from pydantic import BaseModel, Field
-from typing import List, Optional
+from typing import Optional
 from fastapi.encoders import jsonable_encoder
 
 app = FastAPI()
 
-class SearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-    max_results: int = Field(10, description="The maximum number of results to return", ge=1, le=100)
-    timelimit: Optional[str] = Field(None, description="The time limit for the search (e.g., 'd' for day, 'w' for week, 'm' for month, 'y' for year)")
-    safesearch: str = Field("moderate", description="The safe search level ('on', 'moderate', or 'off')")
-    region: str = Field("wt-wt", description="The region for the search (e.g., 'us-en', 'uk-en', 'ru-ru')")
-    backend: str = Field("api", description="The backend to use for search ('api', 'html', or 'lite')")
-
-class ImageSearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-    max_results: int = Field(10, description="The maximum number of results to return", ge=1, le=100)
-    safesearch: str = Field("moderate", description="The safe search level ('on', 'moderate', or 'off')")
-    region: str = Field("wt-wt", description="The region for the search (e.g., 'us-en', 'uk-en', 'ru-ru')")
-    timelimit: Optional[str] = Field(None, description="The time limit for the search ('Day', 'Week', 'Month', or 'Year')")
-    size: Optional[str] = Field(None, description="The size of the images ('Small', 'Medium', 'Large', or 'Wallpaper')")
-    color: Optional[str] = Field(None, description="The color of the images ('color', 'Monochrome', 'Red', etc.)")
-    type_image: Optional[str] = Field(None, description="The type of images ('photo', 'clipart', 'gif', etc.)")
-    layout: Optional[str] = Field(None, description="The layout of the images ('Square', 'Tall', or 'Wide')")
-    license_image: Optional[str] = Field(None, description="The license of the images ('any', 'Public', 'Share', etc.)")
-
-class VideoSearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-    max_results: int = Field(10, description="The maximum number of results to return", ge=1, le=100)
-    safesearch: str = Field("moderate", description="The safe search level ('on', 'moderate', or 'off')")
-    region: str = Field("wt-wt", description="The region for the search (e.g., 'us-en', 'uk-en', 'ru-ru')")
-    timelimit: Optional[str] = Field(None, description="The time limit for the search (e.g., 'd' for day, 'w' for week, 'm' for month)")
-    resolution: Optional[str] = Field(None, description="The resolution of the videos ('high' or 'standard')")
-    duration: Optional[str] = Field(None, description="The duration of the videos ('short', 'medium', or 'long')")
-    license_videos: Optional[str] = Field(None, description="The license of the videos ('creativeCommon' or 'youtube')")
-
-class NewsSearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-    max_results: int = Field(10, description="The maximum number of results to return", ge=1, le=100)
-    safesearch: str = Field("moderate", description="The safe search level ('on', 'moderate', or 'off')")
-    region: str = Field("wt-wt", description="The region for the search (e.g., 'us-en', 'uk-en', 'ru-ru')")
-    timelimit: Optional[str] = Field(None, description="The time limit for the search (e.g., 'd' for day, 'w' for week, 'm' for month, 'y' for year)")
-
-class AnswersSearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-
-class SuggestionsSearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-    region: str = Field("wt-wt", description="The region for suggestions (e.g., 'us-en', 'uk-en', 'ru-ru')")
-
-class MapsSearchQuery(BaseModel):
-    q: str = Field(..., description="The search query string")
-    place: Optional[str] = Field(None, description="Simplified search - if set, other location parameters are ignored")
-    street: Optional[str] = Field(None, description="Street address")
-    city: Optional[str] = Field(None, description="City")
-    county: Optional[str] = Field(None, description="County")
-    state: Optional[str] = Field(None, description="State")
-    country: Optional[str] = Field(None, description="Country")
-    postalcode: Optional[str] = Field(None, description="Postal code")
-    latitude: Optional[str] = Field(None, description="Latitude (if used, other location parameters are ignored)")
-    longitude: Optional[str] = Field(None, description="Longitude (if used, other location parameters are ignored)")
-    radius: int = Field(0, description="Expand the search radius in kilometers")
-    max_results: int = Field(10, description="The maximum number of results to return", ge=1, le=100)
-
-class TranslateSearchQuery(BaseModel):
-    q: str = Field(..., description="The text to translate")
-    from_: Optional[str] = Field(None, description="The source language (defaults to automatic detection)")
-    to: str = Field("en", description="The target language (defaults to English)")
-
-class TranscriptQuery(BaseModel):
-    video_id: str = Field(..., description="The YouTube video ID")
-    languages: str = Field("en", description="Comma-separated list of language codes (e.g., 'en,es')")
-    preserve_formatting: bool = Field(False, description="Whether to preserve text formatting")
-
 @app.get("/")
 async def root():
-    return {"message": "Welcome to HelpingAI API!"}
+    return {"message": "API documentation can be found at /docs"}
 
 @app.get("/health")
 async def health_check():
     return {"status": "OK"}
 
 @app.get("/api/search")
-async def search(request: Request, query: SearchQuery):
+async def search(
+    q: str,
+    max_results: int = 10,
+    timelimit: Optional[str] = None,
+    safesearch: str = "moderate",
+    region: str = "wt-wt",
+    backend: str = "api"
+):
     """Perform a text search."""
     try:
         with WEBS() as webs:
-            results = webs.text(keywords=query.q, region=query.region, safesearch=query.safesearch, timelimit=query.timelimit, backend=query.backend, max_results=query.max_results)
+            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}")
 
 @app.get("/api/images")
-async def images(request: Request, query: ImageSearchQuery):
+async def images(
+    q: str,
+    max_results: int = 10,
+    safesearch: str = "moderate",
+    region: str = "wt-wt",
+    timelimit: Optional[str] = None,
+    size: Optional[str] = None,
+    color: Optional[str] = None,
+    type_image: Optional[str] = None,
+    layout: Optional[str] = None,
+    license_image: Optional[str] = None
+):
     """Perform an image search."""
     try:
         with WEBS() as webs:
-            results = webs.images(keywords=query.q, region=query.region, safesearch=query.safesearch, timelimit=query.timelimit, size=query.size, color=query.color, type_image=query.type_image, layout=query.layout, license_image=query.license_image, max_results=query.max_results)
+            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}")
 
 @app.get("/api/videos")
-async def videos(request: Request, query: VideoSearchQuery):
+async def videos(
+    q: str,
+    max_results: int = 10,
+    safesearch: str = "moderate",
+    region: str = "wt-wt",
+    timelimit: Optional[str] = None,
+    resolution: Optional[str] = None,
+    duration: Optional[str] = None,
+    license_videos: Optional[str] = None
+):
     """Perform a video search."""
     try:
         with WEBS() as webs:
-            results = webs.videos(keywords=query.q, region=query.region, safesearch=query.safesearch, timelimit=query.timelimit, resolution=query.resolution, duration=query.duration, license_videos=query.license_videos, max_results=query.max_results)
+            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(request: Request, query: NewsSearchQuery):
+async def news(
+    q: str,
+    max_results: int = 10,
+    safesearch: str = "moderate",
+    region: str = "wt-wt",
+    timelimit: Optional[str] = None
+):
     """Perform a news search."""
     try:
         with WEBS() as webs:
-            results = webs.news(keywords=query.q, region=query.region, safesearch=query.safesearch, timelimit=query.timelimit, max_results=query.max_results)
+            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/answers")
-async def answers(request: Request, query: AnswersSearchQuery):
+async def answers(q: str):
     """Get instant answers for a query."""
     try:
         with WEBS() as webs:
-            results = webs.answers(keywords=query.q)
+            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(request: Request, query: SuggestionsSearchQuery):
+async def suggestions(q: str, region: str = "wt-wt"):
     """Get search suggestions for a query."""
     try:
         with WEBS() as webs:
-            results = webs.suggestions(keywords=query.q, region=query.region)
+            results = webs.suggestions(keywords=q, region=region)
             return JSONResponse(content=jsonable_encoder(results))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting search suggestions: {e}")
 
 @app.get("/api/maps")
-async def maps(request: Request, query: MapsSearchQuery):
+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
+):
     """Perform a maps search."""
     try:
         with WEBS() as webs:
-            results = webs.maps(keywords=query.q, place=query.place, street=query.street, city=query.city, county=query.county, state=query.state, country=query.country, postalcode=query.postalcode, latitude=query.latitude, longitude=query.longitude, radius=query.radius, max_results=query.max_results)
+            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(request: Request, query: TranslateSearchQuery):
+async def translate(
+    q: str,
+    from_: Optional[str] = None,
+    to: str = "en"
+):
     """Translate text."""
     try:
         with WEBS() as webs:
-            results = webs.translate(keywords=query.q, from_=query.from_, to=query.to)
+            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}")
 
 @app.get("/api/youtube/transcript")
-async def youtube_transcript(request: Request, query: TranscriptQuery):
+async def youtube_transcript(
+    video_id: str,
+    languages: str = "en",
+    preserve_formatting: bool = False
+):
     """Get the transcript of a YouTube video."""
     try:
-        languages = query.languages.split(",")
-        transcript = transcriber.get_transcript(query.video_id, languages=languages, preserve_formatting=query.preserve_formatting)
+        languages_list = languages.split(",")
+        transcript = transcriber.get_transcript(video_id, languages=languages_list, preserve_formatting=preserve_formatting)
         return JSONResponse(content=jsonable_encoder(transcript))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting YouTube transcript: {e}")