webscout 7.1__py3-none-any.whl → 7.3__py3-none-any.whl

webscout/update_checker.py

@@ -15,7 +15,7 @@ import requests
 from packaging import version
 import re
 
-from webscout import LitLogger, ColorScheme
+from webscout.Litlogger import Logger
 from importlib.metadata import version as get_package_version
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import metadata as get_package_metadata
@@ -23,19 +23,9 @@ from importlib.metadata import metadata as get_package_metadata
 # Setting up that clean logger format, no cap! 💯
 CUSTOM_FORMAT = """{message}"""
 
-logger = LitLogger(
+logger = Logger(
     name="WebscoutUpdate",
     format=CUSTOM_FORMAT,
-    color_scheme=ColorScheme.OCEAN,
-    level_styles={
-        "TRACE": "DIM",
-        "DEBUG": "NORMAL", 
-        "INFO": "BOLD",
-        "SUCCESS": "BOLD",
-        "WARNING": "BOLD",
-        "ERROR": "BOLD",
-        "CRITICAL": "BOLD"
-    }
 )
 
 def get_installed_version() -> Optional[str]:

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "7.1"
+__version__ = "7.3"
 __prog__ = "webscout"

webscout/webscout_search.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 # import logging
+import json
+from urllib.parse import quote
 import warnings
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
@@ -11,7 +13,7 @@ from random import choice, shuffle
 from threading import Event
 from time import sleep, time
 from types import TracebackType
-from typing import cast
+from typing import Any, cast
 
 import primp  # type: ignore
 
@@ -178,7 +180,8 @@ class WEBS:
         """
         models_deprecated = {
             "gpt-3.5": "gpt-4o-mini",
-            "llama-3-70b": "llama-3.1-70b"
+            "llama-3.1-70b": "llama-3.3-70b",
+            "mixtral-8x7b": "mistral-24B"
         }
         if model in models_deprecated:
             # logger.info(f"{model=} is deprecated, using {models_deprecated[model]}")
@@ -186,9 +189,9 @@ class WEBS:
         models = {
             "claude-3-haiku": "claude-3-haiku-20240307",
             "gpt-4o-mini": "gpt-4o-mini",
-            "llama-3.1-70b": "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
-            "mixtral-8x7b": "mistralai/Mixtral-8x7B-Instruct-v0.1",
-            "o3-mini":"o3-mini"
+            "llama-3.3-70b": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            "o3-mini":"o3-mini",
+            "mistral-24B": "mistralai/Mistral-Small-24B-Instruct-2501"
         }
         # vqd
         if not self._chat_vqd:
@@ -1139,4 +1142,82 @@ class WEBS:
         except Exception as e:
             raise e
 
-        return results
+        return results
+
+    def weather(
+        self,
+        location: str,
+        language: str = "en",
+    ) -> dict[str, Any]:
+        """Get weather information for a location from DuckDuckGo.
+
+        Args:
+            location: Location to get weather for.
+            language: Language code (e.g. 'en', 'es'). Defaults to "en".
+
+        Returns:
+            Dictionary containing weather data with structure described in docstring.
+
+        Raises:
+            WebscoutE: Base exception for webscout errors.
+            RatelimitE: Inherits from WebscoutE, raised for exceeding API request rate limits.
+            TimeoutE: Inherits from WebscoutE, raised for API request timeouts.
+        """
+        assert location, "location is mandatory"
+        lang = language.split('-')[0]
+        url = f"https://duckduckgo.com/js/spice/forecast/{quote(location)}/{lang}"
+        
+        resp = self._get_url("GET", url)
+        resp_text = resp.decode('utf-8')
+        
+        if "ddg_spice_forecast(" not in resp_text:
+            raise WebscoutE(f"No weather data found for {location}")
+        
+        json_text = resp_text[resp_text.find('(') + 1:resp_text.rfind(')')]
+        try:
+            result = json.loads(json_text)
+        except Exception as e:
+            raise WebscoutE(f"Error parsing weather JSON: {e}")
+        
+        if not result or 'currentWeather' not in result or 'forecastDaily' not in result:
+            raise WebscoutE(f"Invalid weather data format for {location}")
+        
+        formatted_data = {
+            "location": result["currentWeather"]["metadata"].get("ddg-location", "Unknown"),
+            "current": {
+                "condition": result["currentWeather"].get("conditionCode"),
+                "temperature_c": result["currentWeather"].get("temperature"),
+                "feels_like_c": result["currentWeather"].get("temperatureApparent"),
+                "humidity": result["currentWeather"].get("humidity"),
+                "wind_speed_ms": result["currentWeather"].get("windSpeed"),
+                "wind_direction": result["currentWeather"].get("windDirection"),
+                "visibility_m": result["currentWeather"].get("visibility"),
+            },
+            "daily_forecast": [],
+            "hourly_forecast": []
+        }
+
+        for day in result["forecastDaily"]["days"]:
+            formatted_data["daily_forecast"].append({
+                "date": datetime.fromisoformat(day["forecastStart"].replace("Z", "+00:00")).strftime("%Y-%m-%d"),
+                "condition": day["daytimeForecast"].get("conditionCode"),
+                "max_temp_c": day["temperatureMax"],
+                "min_temp_c": day["temperatureMin"],
+                "sunrise": datetime.fromisoformat(day["sunrise"].replace("Z", "+00:00")).strftime("%H:%M"),
+                "sunset": datetime.fromisoformat(day["sunset"].replace("Z", "+00:00")).strftime("%H:%M"),
+            })
+
+        if 'forecastHourly' in result and 'hours' in result['forecastHourly']:
+            for hour in result['forecastHourly']['hours']:
+                formatted_data["hourly_forecast"].append({
+                    "time": datetime.fromisoformat(hour["forecastStart"].replace("Z", "+00:00")).strftime("%H:%M"),
+                    "condition": hour.get("conditionCode"),
+                    "temperature_c": hour.get("temperature"),
+                    "feels_like_c": hour.get("temperatureApparent"),
+                    "humidity": hour.get("humidity"),
+                    "wind_speed_ms": hour.get("windSpeed"),
+                    "wind_direction": hour.get("windDirection"),
+                    "visibility_m": hour.get("visibility"),
+                })
+
+        return formatted_data

webscout/webscout_search_async.py

@@ -633,4 +633,61 @@ class AsyncWEBS:
             from_,
             to,
         )
-        return result
+        return result
+
+    async def aweather(
+        self,
+        location: str,
+        language: str = "en",
+    ) -> dict[str, Any]:
+        """Async version of weather information retrieval from DuckDuckGo.
+
+        Args:
+            location: Location to get weather for.
+            language: Language code (e.g. 'en', 'es'). Defaults to "en".
+
+        Returns:
+            Dictionary containing weather data with the following structure:
+            {
+                "location": str,
+                "current": {
+                    "condition": str,
+                    "temperature_c": float,
+                    "feels_like_c": float,
+                    "humidity": float,
+                    "wind_speed_ms": float,
+                    "wind_direction": float,
+                    "visibility_m": float
+                },
+                "daily_forecast": List[{
+                    "date": str,
+                    "condition": str,
+                    "max_temp_c": float,
+                    "min_temp_c": float,
+                    "sunrise": str,
+                    "sunset": str
+                }],
+                "hourly_forecast": List[{
+                    "time": str,
+                    "condition": str,
+                    "temperature_c": float,
+                    "feels_like_c": float,
+                    "humidity": float,
+                    "wind_speed_ms": float,
+                    "wind_direction": float,
+                    "visibility_m": float
+                }]
+            }
+
+        Raises:
+            WebscoutE: Base exception for webscout errors.
+            RatelimitE: Inherits from WebscoutE, raised for exceeding API request rate limits.
+            TimeoutE: Inherits from WebscoutE, raised for API request timeouts.
+        """
+        result = await self._loop.run_in_executor(
+            self._executor,
+            super().weather,
+            location,
+            language,
+        )
+        return result

webscout/yep_search.py

@@ -0,0 +1,297 @@
+import cloudscraper
+from urllib.parse import urlencode
+from webscout.litagent import LitAgent
+from typing import List, Dict, Optional, Tuple
+from concurrent.futures import ThreadPoolExecutor
+import json
+class YepSearch:
+    """Yep.com search class to get search results."""
+    
+    _executor: ThreadPoolExecutor = ThreadPoolExecutor()
+
+    def __init__(
+        self,
+        timeout: int = 20,
+        proxies: Dict[str, str] | None = None,
+        verify: bool = True,
+    ):
+        """Initialize YepSearch.
+        
+        Args:
+            timeout: Timeout value for the HTTP client. Defaults to 20.
+            proxies: Proxy configuration for requests. Defaults to None.
+            verify: Verify SSL certificates. Defaults to True.
+        """
+        self.base_url = "https://api.yep.com/fs/2/search"
+        self.timeout = timeout
+        self.session = cloudscraper.create_scraper()
+        self.session.headers.update({
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "DNT": "1",
+            "Origin": "https://yep.com",
+            "Referer": "https://yep.com/",
+            "Sec-Ch-Ua": '"Not(A:Brand";v="99", "Microsoft Edge";v="133", "Chromium";v="133"',
+            "Sec-Ch-Ua-Mobile": "?0",
+            "Sec-Ch-Ua-Platform": '"Windows"',
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-site",
+            "User-Agent": LitAgent().random()
+        })
+        if proxies:
+            self.session.proxies.update(proxies)
+        self.session.verify = verify
+
+    def _remove_html_tags(self, text: str) -> str:
+        """Remove HTML tags from text using simple string manipulation.
+        
+        Args:
+            text: String containing HTML tags
+            
+        Returns:
+            Clean text without HTML tags
+        """
+        result = ""
+        in_tag = False
+        
+        for char in text:
+            if char == '<':
+                in_tag = True
+            elif char == '>':
+                in_tag = False
+            elif not in_tag:
+                result += char
+                
+        # Replace common HTML entities
+        replacements = {
+            '&nbsp;': ' ',
+            '&amp;': '&',
+            '&lt;': '<',
+            '&gt;': '>',
+            '&quot;': '"',
+            '&apos;': "'",
+        }
+        
+        for entity, replacement in replacements.items():
+            result = result.replace(entity, replacement)
+            
+        return result.strip()
+
+    def format_results(self, raw_results: dict) -> List[Dict]:
+        """Format raw API results into a consistent structure."""
+        formatted_results = []
+        
+        if not raw_results or len(raw_results) < 2:
+            return formatted_results
+
+        results = raw_results[1].get('results', [])
+        
+        for result in results:
+            formatted_result = {
+                "title": self._remove_html_tags(result.get("title", "")),
+                "href": result.get("url", ""),
+                "body": self._remove_html_tags(result.get("snippet", "")),
+                "source": result.get("visual_url", ""),
+                "position": len(formatted_results) + 1,
+                "type": result.get("type", "organic"),
+                "first_seen": result.get("first_seen", None)
+            }
+            
+            # Add sitelinks if they exist
+            if "sitelinks" in result:
+                sitelinks = []
+                if "full" in result["sitelinks"]:
+                    sitelinks.extend(result["sitelinks"]["full"])
+                if "short" in result["sitelinks"]:
+                    sitelinks.extend(result["sitelinks"]["short"])
+                
+                if sitelinks:
+                    formatted_result["sitelinks"] = [
+                        {
+                            "title": self._remove_html_tags(link.get("title", "")),
+                            "href": link.get("url", "")
+                        }
+                        for link in sitelinks
+                    ]
+            
+            formatted_results.append(formatted_result)
+        
+        return formatted_results
+
+    def text(
+        self,
+        keywords: str,
+        region: str = "all",
+        safesearch: str = "moderate",
+        max_results: Optional[int] = None,
+    ) -> List[Dict[str, str]]:
+        """Yep.com text search.
+
+        Args:
+            keywords: Search query string.
+            region: Region for search results. Defaults to "all".
+            safesearch: SafeSearch setting ("on", "moderate", "off"). Defaults to "moderate".
+            max_results: Maximum number of results to return. Defaults to None.
+
+        Returns:
+            List of dictionaries containing search results.
+        """
+        # Convert safesearch parameter
+        safe_search_map = {
+            "on": "on",
+            "moderate": "moderate",
+            "off": "off"
+        }
+        safe_setting = safe_search_map.get(safesearch.lower(), "moderate")
+
+        params = {
+            "client": "web",
+            "gl": region,
+            "limit": str(max_results) if max_results else "10",
+            "no_correct": "false",
+            "q": keywords,
+            "safeSearch": safe_setting,
+            "type": "web"
+        }
+        
+        url = f"{self.base_url}?{urlencode(params)}"
+        try:
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            raw_results = response.json()
+            
+            formatted_results = self.format_results(raw_results)
+            
+            if max_results:
+                return formatted_results[:max_results]
+            return formatted_results
+        except Exception as e:
+            raise Exception(f"Yep search failed: {str(e)}")
+
+    def images(
+        self,
+        keywords: str,
+        region: str = "all",
+        safesearch: str = "moderate",
+        max_results: Optional[int] = None,
+    ) -> List[Dict[str, str]]:
+        """Yep.com image search.
+
+        Args:
+            keywords: Search query string.
+            region: Region for search results. Defaults to "all".
+            safesearch: SafeSearch setting ("on", "moderate", "off"). Defaults to "moderate".
+            max_results: Maximum number of results to return. Defaults to None.
+
+        Returns:
+            List of dictionaries containing image search results with keys:
+            - title: Image title
+            - image: Full resolution image URL
+            - thumbnail: Thumbnail image URL
+            - url: Source page URL
+            - height: Image height
+            - width: Image width
+            - source: Source website domain
+        """
+        safe_search_map = {
+            "on": "on",
+            "moderate": "moderate",
+            "off": "off"
+        }
+        safe_setting = safe_search_map.get(safesearch.lower(), "moderate")
+
+        params = {
+            "client": "web",
+            "gl": region,
+            "limit": str(max_results) if max_results else "10",
+            "no_correct": "false",
+            "q": keywords,
+            "safeSearch": safe_setting,
+            "type": "images"
+        }
+        
+        url = f"{self.base_url}?{urlencode(params)}"
+        try:
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            raw_results = response.json()
+            
+            if not raw_results or len(raw_results) < 2:
+                return []
+
+            formatted_results = []
+            results = raw_results[1].get('results', [])
+            
+            for result in results:
+                if result.get("type") != "Image":
+                    continue
+                
+                formatted_result = {
+                    "title": self._remove_html_tags(result.get("title", "")),
+                    "image": result.get("image_id", ""),
+                    "thumbnail": result.get("src", ""),
+                    "url": result.get("host_page", ""),
+                    "height": result.get("height", 0),
+                    "width": result.get("width", 0),
+                    "source": result.get("visual_url", "")
+                }
+                
+                # Add high-res thumbnail if available
+                if "srcset" in result:
+                    formatted_result["thumbnail_hd"] = result["srcset"].split(",")[1].strip().split(" ")[0]
+                
+                formatted_results.append(formatted_result)
+            
+            if max_results:
+                return formatted_results[:max_results]
+            return formatted_results
+        
+        except Exception as e:
+            raise Exception(f"Yep image search failed: {str(e)}")
+
+    def suggestions(
+        self,
+        query: str,
+        region: str = "all",
+    ) -> List[str]:
+        """Get search suggestions from Yep.com autocomplete API.
+
+        Args:
+            query: Search query string to get suggestions for.
+            region: Region for suggestions. Defaults to "all".
+
+        Returns:
+            List of suggestion strings.
+
+        Example:
+            >>> yep = YepSearch()
+            >>> suggestions = yep.suggestions("ca")
+            >>> print(suggestions)
+            ['capital one', 'car wash', 'carmax', 'cafe', ...]
+        """
+        params = {
+            "query": query,
+            "type": "web",
+            "gl": region
+        }
+        
+        url = f"https://api.yep.com/ac/?{urlencode(params)}"
+        
+        try:
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+            # Return suggestions list if response format is valid
+            if isinstance(data, list) and len(data) > 1 and isinstance(data[1], list):
+                return data[1]
+            return []
+        
+        except Exception as e:
+            raise Exception(f"Yep suggestions failed: {str(e)}")
+
+
+if __name__ == "__main__":
+    yep = YepSearch()
+    r = yep.suggestions("hi", region="all")
+    print(r)

webscout/zeroart/__init__.py

@@ -1,55 +1,55 @@
-"""
-ZeroArt: A zero-dependency ASCII art text generator
-
-Create awesome ASCII art text without external dependencies!
-"""
-
-from .base import ZeroArtFont
-from .fonts import BlockFont, SlantFont, NeonFont, CyberFont
-from .effects import AsciiArtEffects
-
-def figlet_format(text, font='block'):
-    """
-    Generate ASCII art text
-    
-    :param text: Text to convert
-    :param font: Font style (default: 'block')
-    :return: ASCII art representation of text
-    """
-    font_map = {
-        'block': BlockFont(),
-        'slant': SlantFont(),
-        'neon': NeonFont(),
-        'cyber': CyberFont()
-    }
-    
-    selected_font = font_map.get(font.lower(), BlockFont())
-    return selected_font.render(text)
-
-def print_figlet(text, font='block'):
-    """
-    Print ASCII art text directly
-    
-    :param text: Text to convert and print
-    :param font: Font style (default: 'block')
-    """
-    print(figlet_format(text, font))
-
-# Expose additional effects
-rainbow = AsciiArtEffects.rainbow_effect
-glitch = AsciiArtEffects.glitch_effect
-wrap_text = AsciiArtEffects.wrap_text
-outline = AsciiArtEffects.outline_effect
-
-__all__ = [
-    'figlet_format', 
-    'print_figlet', 
-    'rainbow', 
-    'glitch', 
-    'wrap_text', 
-    'outline',
-    'BlockFont', 
-    'SlantFont', 
-    'NeonFont', 
-    'CyberFont'
+"""
+ZeroArt: A zero-dependency ASCII art text generator
+
+Create awesome ASCII art text without external dependencies!
+"""
+
+from .base import ZeroArtFont
+from .fonts import BlockFont, SlantFont, NeonFont, CyberFont
+from .effects import AsciiArtEffects
+
+def figlet_format(text, font='block'):
+    """
+    Generate ASCII art text
+    
+    :param text: Text to convert
+    :param font: Font style (default: 'block')
+    :return: ASCII art representation of text
+    """
+    font_map = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont()
+    }
+    
+    selected_font = font_map.get(font.lower(), BlockFont())
+    return selected_font.render(text)
+
+def print_figlet(text, font='block'):
+    """
+    Print ASCII art text directly
+    
+    :param text: Text to convert and print
+    :param font: Font style (default: 'block')
+    """
+    print(figlet_format(text, font))
+
+# Expose additional effects
+rainbow = AsciiArtEffects.rainbow_effect
+glitch = AsciiArtEffects.glitch_effect
+wrap_text = AsciiArtEffects.wrap_text
+outline = AsciiArtEffects.outline_effect
+
+__all__ = [
+    'figlet_format', 
+    'print_figlet', 
+    'rainbow', 
+    'glitch', 
+    'wrap_text', 
+    'outline',
+    'BlockFont', 
+    'SlantFont', 
+    'NeonFont', 
+    'CyberFont'
 ]