webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/Extra/weather.py

@@ -1,194 +1,196 @@
-"""
-Weather information module with a clean, strongly-typed API structure.
-
-This module provides a simple client for fetching weather data
-from the wttr.in service with proper typing and a consistent interface.
-"""
-
-import requests
-from datetime import datetime
-from typing import List, Dict, Any, Optional
-
-
-class CurrentCondition:
-    """Current weather conditions with strongly typed properties."""
-    
-    def __init__(self, data: Dict[str, Any]) -> None:
-        """Initialize with current condition data.
-        
-        Args:
-            data: Current condition data dictionary from wttr.in
-        """
-        self.temp_c: Optional[str] = data.get('temp_C')
-        self.temp_f: Optional[str] = data.get('temp_F')
-        self.feels_like_c: Optional[str] = data.get('FeelsLikeC')
-        self.feels_like_f: Optional[str] = data.get('FeelsLikeF')
-        self.weather_desc: str = data.get('weatherDesc', [{}])[0].get('value', '')
-        self.weather_code: Optional[str] = data.get('weatherCode')
-        self.humidity: Optional[str] = data.get('humidity')
-        self.visibility: Optional[str] = data.get('visibility')
-        self.pressure: Optional[str] = data.get('pressure')
-        self.wind_speed_kmph: Optional[str] = data.get('windspeedKmph')
-        self.wind_direction: Optional[str] = data.get('winddir16Point')
-        self.wind_degree: Optional[str] = data.get('winddirDegree')
-
-
-class Location:
-    """Location information with strongly typed properties."""
-    
-    def __init__(self, data: Dict[str, Any]) -> None:
-        """Initialize with location data.
-        
-        Args:
-            data: Location data dictionary from wttr.in
-        """
-        self.name: str = data.get('areaName', [{}])[0].get('value', '')
-        self.country: str = data.get('country', [{}])[0].get('value', '')
-        self.region: str = data.get('region', [{}])[0].get('value', '')
-        self.latitude: Optional[str] = data.get('latitude')
-        self.longitude: Optional[str] = data.get('longitude')
-
-
-class HourlyForecast:
-    """Hourly forecast information with strongly typed properties."""
-    
-    def __init__(self, data: Dict[str, Any]) -> None:
-        """Initialize with hourly forecast data.
-        
-        Args:
-            data: Hourly forecast data dictionary from wttr.in
-        """
-        self.time: Optional[str] = data.get('time')
-        self.temp_c: Optional[str] = data.get('tempC')
-        self.temp_f: Optional[str] = data.get('tempF')
-        self.weather_desc: str = data.get('weatherDesc', [{}])[0].get('value', '')
-        self.weather_code: Optional[str] = data.get('weatherCode')
-        self.wind_speed_kmph: Optional[str] = data.get('windspeedKmph')
-        self.wind_direction: Optional[str] = data.get('winddir16Point')
-        self.feels_like_c: Optional[str] = data.get('FeelsLikeC')
-        self.feels_like_f: Optional[str] = data.get('FeelsLikeF')
-        self.chance_of_rain: Optional[str] = data.get('chanceofrain')
-        self.chance_of_snow: Optional[str] = data.get('chanceofsnow')
-
-
-class DayForecast:
-    """Daily forecast information with strongly typed properties."""
-    
-    def __init__(self, data: Dict[str, Any]) -> None:
-        """Initialize with daily forecast data.
-        
-        Args:
-            data: Daily forecast data dictionary from wttr.in
-        """
-        self.date: Optional[str] = data.get('date')
-        self.date_formatted: Optional[str] = None
-        if self.date:
-            try:
-                self.date_formatted = datetime.strptime(self.date, '%Y-%m-%d').strftime('%a, %b %d')
-            except ValueError:
-                pass
-        
-        self.max_temp_c: Optional[str] = data.get('maxtempC')
-        self.max_temp_f: Optional[str] = data.get('maxtempF')
-        self.min_temp_c: Optional[str] = data.get('mintempC')
-        self.min_temp_f: Optional[str] = data.get('mintempF')
-        self.avg_temp_c: Optional[str] = data.get('avgtempC')
-        self.avg_temp_f: Optional[str] = data.get('avgtempF')
-        self.sun_hour: Optional[str] = data.get('sunHour')
-        
-        # Parse astronomy data (simplified)
-        if data.get('astronomy') and len(data.get('astronomy', [])) > 0:
-            astro = data.get('astronomy', [{}])[0]
-            self.sunrise: Optional[str] = astro.get('sunrise')
-            self.sunset: Optional[str] = astro.get('sunset')
-            self.moon_phase: Optional[str] = astro.get('moon_phase')
-        else:
-            self.sunrise = self.sunset = self.moon_phase = None
-        
-        # Parse hourly forecasts
-        self.hourly: List[HourlyForecast] = []
-        for hour_data in data.get('hourly', []):
-            self.hourly.append(HourlyForecast(hour_data))
-
-
-class Weather:
-    """Weather response object with strongly typed properties."""
-    
-    def __init__(self, data: Optional[Dict[str, Any]] = None) -> None:
-        """Initialize with weather data.
-        
-        Args:
-            data: Weather data dictionary from wttr.in
-        """
-        if not data:
-            self.current_condition = None
-            self.location = None
-            self.forecast_days = []
-            return
-            
-        # Parse current condition
-        self.current_condition: Optional[CurrentCondition] = None
-        if data.get('current_condition') and len(data.get('current_condition', [])) > 0:
-            self.current_condition = CurrentCondition(data.get('current_condition', [{}])[0])
-            
-        # Parse location
-        self.location: Optional[Location] = None
-        if data.get('nearest_area') and len(data.get('nearest_area', [])) > 0:
-            self.location = Location(data.get('nearest_area', [{}])[0])
-            
-        # Parse forecast days
-        self.forecast_days: List[DayForecast] = []
-        for day_data in data.get('weather', []):
-            self.forecast_days.append(DayForecast(day_data))
-    
-    @property
-    def today(self) -> Optional[DayForecast]:
-        """Get today's forecast."""
-        return self.forecast_days[0] if self.forecast_days else None
-    
-    @property
-    def tomorrow(self) -> Optional[DayForecast]:
-        """Get tomorrow's forecast."""
-        return self.forecast_days[1] if len(self.forecast_days) > 1 else None
-    
-    @property
-    def summary(self) -> str:
-        """Get a simple text summary of current weather."""
-        if not self.current_condition or not self.location:
-            return "Weather data not available"
-            
-        return f"{self.location.name}, {self.location.country}: {self.current_condition.weather_desc}, {self.current_condition.temp_c}°C ({self.current_condition.temp_f}°F)"
-
-
-class WeatherClient:
-    """Client for fetching weather information."""
-    
-    def get_weather(self, location: str) -> Weather:
-        """Get weather for the specified location.
-        
-        Args:
-            location: Location to get weather for (city name, zip code, etc.)
-            
-        Returns:
-            Weather object containing all weather data
-        """
-        try:
-            response = requests.get(f"https://wttr.in/{location}?format=j1", timeout=10)
-            response.raise_for_status()
-            return Weather(response.json())
-        except Exception as e:
-            print(f"Error fetching weather data: {str(e)}")
-            return Weather()
-
-
-def get(location: str) -> Weather:
-    """Convenience function to get weather for a location.
-    
-    Args:
-        location: Location to get weather for
-        
-    Returns:
-        Weather object containing all weather data
-    """
-    client = WeatherClient()
-    return client.get_weather(location)
+"""
+Weather information module with a clean, strongly-typed API structure.
+
+This module provides a simple client for fetching weather data
+from the wttr.in service with proper typing and a consistent interface.
+"""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from curl_cffi.requests import Session
+
+
+class CurrentCondition:
+    """Current weather conditions with strongly typed properties."""
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with current condition data.
+
+        Args:
+            data: Current condition data dictionary from wttr.in
+        """
+        self.temp_c: Optional[str] = data.get('temp_C')
+        self.temp_f: Optional[str] = data.get('temp_F')
+        self.feels_like_c: Optional[str] = data.get('FeelsLikeC')
+        self.feels_like_f: Optional[str] = data.get('FeelsLikeF')
+        self.weather_desc: str = data.get('weatherDesc', [{}])[0].get('value', '')
+        self.weather_code: Optional[str] = data.get('weatherCode')
+        self.humidity: Optional[str] = data.get('humidity')
+        self.visibility: Optional[str] = data.get('visibility')
+        self.pressure: Optional[str] = data.get('pressure')
+        self.wind_speed_kmph: Optional[str] = data.get('windspeedKmph')
+        self.wind_direction: Optional[str] = data.get('winddir16Point')
+        self.wind_degree: Optional[str] = data.get('winddirDegree')
+
+
+class Location:
+    """Location information with strongly typed properties."""
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with location data.
+
+        Args:
+            data: Location data dictionary from wttr.in
+        """
+        self.name: str = data.get('areaName', [{}])[0].get('value', '')
+        self.country: str = data.get('country', [{}])[0].get('value', '')
+        self.region: str = data.get('region', [{}])[0].get('value', '')
+        self.latitude: Optional[str] = data.get('latitude')
+        self.longitude: Optional[str] = data.get('longitude')
+
+
+class HourlyForecast:
+    """Hourly forecast information with strongly typed properties."""
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with hourly forecast data.
+
+        Args:
+            data: Hourly forecast data dictionary from wttr.in
+        """
+        self.time: Optional[str] = data.get('time')
+        self.temp_c: Optional[str] = data.get('tempC')
+        self.temp_f: Optional[str] = data.get('tempF')
+        self.weather_desc: str = data.get('weatherDesc', [{}])[0].get('value', '')
+        self.weather_code: Optional[str] = data.get('weatherCode')
+        self.wind_speed_kmph: Optional[str] = data.get('windspeedKmph')
+        self.wind_direction: Optional[str] = data.get('winddir16Point')
+        self.feels_like_c: Optional[str] = data.get('FeelsLikeC')
+        self.feels_like_f: Optional[str] = data.get('FeelsLikeF')
+        self.chance_of_rain: Optional[str] = data.get('chanceofrain')
+        self.chance_of_snow: Optional[str] = data.get('chanceofsnow')
+
+
+class DayForecast:
+    """Daily forecast information with strongly typed properties."""
+
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with daily forecast data.
+
+        Args:
+            data: Daily forecast data dictionary from wttr.in
+        """
+        self.date: Optional[str] = data.get('date')
+        self.date_formatted: Optional[str] = None
+        if self.date:
+            try:
+                self.date_formatted = datetime.strptime(self.date, '%Y-%m-%d').strftime('%a, %b %d')
+            except ValueError:
+                pass
+
+        self.max_temp_c: Optional[str] = data.get('maxtempC')
+        self.max_temp_f: Optional[str] = data.get('maxtempF')
+        self.min_temp_c: Optional[str] = data.get('mintempC')
+        self.min_temp_f: Optional[str] = data.get('mintempF')
+        self.avg_temp_c: Optional[str] = data.get('avgtempC')
+        self.avg_temp_f: Optional[str] = data.get('avgtempF')
+        self.sun_hour: Optional[str] = data.get('sunHour')
+
+        # Parse astronomy data (simplified)
+        if data.get('astronomy') and len(data.get('astronomy', [])) > 0:
+            astro = data.get('astronomy', [{}])[0]
+            self.sunrise: Optional[str] = astro.get('sunrise')
+            self.sunset: Optional[str] = astro.get('sunset')
+            self.moon_phase: Optional[str] = astro.get('moon_phase')
+        else:
+            self.sunrise = self.sunset = self.moon_phase = None
+
+        # Parse hourly forecasts
+        self.hourly: List[HourlyForecast] = []
+        for hour_data in data.get('hourly', []):
+            self.hourly.append(HourlyForecast(hour_data))
+
+
+class Weather:
+    """Weather response object with strongly typed properties."""
+
+    def __init__(self, data: Optional[Dict[str, Any]] = None) -> None:
+        """Initialize with weather data.
+
+        Args:
+            data: Weather data dictionary from wttr.in
+        """
+        if not data:
+            self.current_condition = None
+            self.location = None
+            self.forecast_days = []
+            return
+
+        # Parse current condition
+        self.current_condition: Optional[CurrentCondition] = None
+        if data.get('current_condition') and len(data.get('current_condition', [])) > 0:
+            self.current_condition = CurrentCondition(data.get('current_condition', [{}])[0])
+
+        # Parse location
+        self.location: Optional[Location] = None
+        if data.get('nearest_area') and len(data.get('nearest_area', [])) > 0:
+            self.location = Location(data.get('nearest_area', [{}])[0])
+
+        # Parse forecast days
+        self.forecast_days: List[DayForecast] = []
+        for day_data in data.get('weather', []):
+            self.forecast_days.append(DayForecast(day_data))
+
+    @property
+    def today(self) -> Optional[DayForecast]:
+        """Get today's forecast."""
+        return self.forecast_days[0] if self.forecast_days else None
+
+    @property
+    def tomorrow(self) -> Optional[DayForecast]:
+        """Get tomorrow's forecast."""
+        return self.forecast_days[1] if len(self.forecast_days) > 1 else None
+
+    @property
+    def summary(self) -> str:
+        """Get a simple text summary of current weather."""
+        if not self.current_condition or not self.location:
+            return "Weather data not available"
+
+        return f"{self.location.name}, {self.location.country}: {self.current_condition.weather_desc}, {self.current_condition.temp_c}°C ({self.current_condition.temp_f}°F)"
+
+
+class WeatherClient:
+    """Client for fetching weather information."""
+
+    def get_weather(self, location: str) -> Weather:
+        """Get weather for the specified location.
+
+        Args:
+            location: Location to get weather for (city name, zip code, etc.)
+
+        Returns:
+            Weather object containing all weather data
+        """
+        try:
+            session = Session()
+            response = session.get(f"https://wttr.in/{location}?format=j1", timeout=10)
+            response.raise_for_status()
+            return Weather(response.json())
+        except Exception as e:
+            print(f"Error fetching weather data: {str(e)}")
+            return Weather()
+
+
+def get(location: str) -> Weather:
+    """Convenience function to get weather for a location.
+
+    Args:
+        location: Location to get weather for
+
+    Returns:
+        Weather object containing all weather data
+    """
+    client = WeatherClient()
+    return client.get_weather(location)

webscout/Extra/weather_ascii.py

@@ -5,26 +5,27 @@ This module provides a clean interface for fetching weather information
 in ASCII art format using the wttr.in service.
 """
 
-import requests
-from typing import Dict, Optional, Any
+from typing import Any, Dict, Optional
+
+from curl_cffi.requests import Session
 
 
 class WeatherAscii:
     """Container for ASCII weather data with a simple API."""
-    
+
     def __init__(self, content: str) -> None:
         """Initialize with ASCII weather content.
-        
+
         Args:
             content: ASCII weather data or error message
         """
         self._content = content
-        
+
     @property
     def content(self) -> str:
         """Get the ASCII content, similar to choices.message.content in OpenAI API."""
         return self._content
-    
+
     def __str__(self) -> str:
         """String representation of ASCII weather."""
         return self.content
@@ -32,24 +33,25 @@ class WeatherAscii:
 
 class WeatherAsciiClient:
     """Client for fetching weather information in ASCII art."""
-    
+
     def get_weather(self, location: str, params: Optional[Dict[str, Any]] = None) -> WeatherAscii:
         """Get ASCII weather for a location.
-        
+
         Args:
             location: The location for which to fetch weather data
             params: Additional parameters for the request
-            
+
         Returns:
             WeatherAscii object containing ASCII art weather data
         """
         url = f"https://wttr.in/{location}"
         headers = {'User-Agent': 'curl'}
-        
+
         try:
-            response = requests.get(url, headers=headers, params=params, timeout=10)
+            session = Session()
+            response = session.get(url, headers=headers, params=params, timeout=10)
             response.raise_for_status()
-            
+
             if response.status_code == 200:
                 # Remove the footer line from wttr.in
                 ascii_weather = "\n".join(response.text.splitlines()[:-1])
@@ -57,17 +59,17 @@ class WeatherAsciiClient:
             else:
                 error_msg = f"Error: Unable to fetch weather data. Status code: {response.status_code}"
                 return WeatherAscii(error_msg)
-        except requests.exceptions.RequestException as e:
+        except Exception as e:
             return WeatherAscii(f"Error: {str(e)}")
 
 
 def get(location: str, params: Optional[Dict[str, Any]] = None) -> WeatherAscii:
     """Convenience function to get ASCII weather for a location.
-    
+
     Args:
         location: Location to get weather for
         params: Additional parameters for the request
-        
+
     Returns:
         WeatherAscii object containing ASCII art weather data
     """

webscout/Provider/AISEARCH/PERPLEXED_search.py

@@ -0,0 +1,175 @@
+from typing import Any, Dict, Generator, List, Optional, Union, cast
+
+import requests
+
+from webscout import exceptions
+from webscout.AIbase import AISearch, SearchResponse
+from webscout.litagent import LitAgent
+from webscout.sanitize import sanitize_stream
+
+
+class PERPLEXED(AISearch):
+    """
+    A class to interact with the PERPLEXED stream search API.
+    """
+
+    def __init__(
+        self,
+        timeout: int = 30,
+        proxies: Optional[dict] = None,
+    ):
+        """Initializes the PERPLEXED API client."""
+        self.session = requests.Session()
+        self.api_endpoint = "https://d21l5c617zttgr.cloudfront.net/stream_search"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "content-type": "application/json",
+            "dnt": "1",
+            "origin": "https://d37ozmhmvu2kcg.cloudfront.net",
+            "referer": "https://d37ozmhmvu2kcg.cloudfront.net/",
+            "sec-ch-ua": '"Not)A;Brand";v="8", "Chromium";v="138", "Microsoft Edge";v="138"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "cross-site",
+            "sec-gpc": "1",
+            "user-agent": LitAgent().random(),
+        }
+        self.session.headers.update(self.headers)
+        self.proxies = proxies
+
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        **kwargs: Any,
+    ) -> Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None], List[Any], Dict[str, Any], str]:
+        """
+        Sends a prompt to the PERPLEXED API and returns the response.
+
+        Args:
+            prompt: The search query or prompt to send to the API
+            stream: Whether to stream the response
+            raw: If True, returns unprocessed response chunks without any
+                processing or sanitization. Useful for debugging or custom
+                processing pipelines. Defaults to False.
+
+        Returns:
+            When raw=False: SearchResponse object (non-streaming) or
+                Generator yielding SearchResponse objects (streaming)
+            When raw=True: Raw string response (non-streaming) or
+                Generator yielding raw string chunks (streaming)
+
+        Examples:
+            >>> ai = PERPLEXED()
+            >>> # Get processed response
+            >>> response = ai.search("Hello")
+            >>> print(response)
+
+            >>> # Get raw response
+            >>> raw_response = ai.search("Hello", raw=True)
+            >>> print(raw_response)
+
+            >>> # Stream raw chunks
+            >>> for chunk in ai.search("Hello", stream=True, raw=True):
+            ...     print(chunk, end='', flush=True)
+        """
+        payload = {"user_prompt": prompt}
+
+        def for_stream():
+            try:
+                with self.session.post(
+                    self.api_endpoint,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    proxies=self.proxies,
+                ) as response:
+                    if not response.ok:
+                        raise exceptions.APIConnectionError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
+
+                    processed_chunks = sanitize_stream(
+                        data=response.iter_content(chunk_size=1024),
+                        intro_value="",
+                        to_json=True,
+                        content_extractor=lambda chunk: (chunk.get("answer") if isinstance(chunk, dict) and chunk.get("success") and chunk.get("answer") is not None else None),
+                        yield_raw_on_error=False,
+                        encoding='utf-8',
+                        encoding_errors='replace',
+                        line_delimiter="[/PERPLEXED-SEPARATOR]",
+                        raw=raw,
+                        output_formatter=None if raw else lambda x: SearchResponse(x) if isinstance(x, str) else x,
+                    )
+
+                    for chunk in processed_chunks:
+                        yield chunk
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.APIConnectionError(f"Request failed: {e}")
+
+        def for_non_stream():
+            try:
+                with self.session.post(
+                    self.api_endpoint,
+                    json=payload,
+                    stream=False,
+                    timeout=self.timeout,
+                    proxies=self.proxies,
+                ) as response:
+                    if not response.ok:
+                        raise exceptions.APIConnectionError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
+
+                    if raw:
+                        # Return raw response text when raw=True
+                        return response.text
+                    else:
+                        # Process response similar to streaming when raw=False
+                        processed_chunks = sanitize_stream(
+                            data=response.content,
+                            intro_value="",
+                            to_json=True,
+                            skip_markers=[],
+                            strip_chars=None,
+                            start_marker=None,
+                            end_marker=None,
+                            content_extractor=lambda chunk: (chunk.get("answer") if isinstance(chunk, dict) and chunk.get("success") and chunk.get("answer") is not None else None),
+                            yield_raw_on_error=False,
+                            encoding='utf-8',
+                            encoding_errors='replace',
+                            buffer_size=8192,
+                            line_delimiter="[/PERPLEXED-SEPARATOR]",
+                            error_handler=None,
+                            skip_regexes=None,
+                            raw=False,
+                            output_formatter=None,
+                        )
+
+                        full_response = ""
+                        for content_chunk in processed_chunks:
+                            if content_chunk is not None and isinstance(content_chunk, str):
+                                full_response += content_chunk
+
+                        self.last_response = SearchResponse(full_response)
+                        return self.last_response
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.APIConnectionError(f"Request failed: {e}")
+
+        return for_stream() if stream else for_non_stream()
+
+
+if __name__ == "__main__":
+    ai = PERPLEXED()
+    response = ai.search("What is Python?", stream=False, raw=False)
+    print(response)