webscout 7.2__py3-none-any.whl → 7.4__py3-none-any.whl

webscout/Provider/yep.py

@@ -12,7 +12,6 @@ from webscout.AIutel import Conversation
 from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import WEBS, exceptions
-from webscout.Litlogger import Logger, LogFormat
 from webscout.litagent import LitAgent
 
 
@@ -24,7 +23,7 @@ class YEPCHAT(Provider):
         AVAILABLE_MODELS (list): List of available models for the provider.
     """
 
-    AVAILABLE_MODELS = ["DeepSeek-R1-Distill-Qwen-32B"]
+    AVAILABLE_MODELS = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
 
     def __init__(
         self,
@@ -39,14 +38,13 @@ class YEPCHAT(Provider):
         act: str = None,
         model: str = "DeepSeek-R1-Distill-Qwen-32B",
         temperature: float = 0.6,
-        top_p: float = 0.7,
-        logging: bool = False,
+        top_p: float = 0.7
     ):
         """
         Initializes the YEPCHAT provider with the specified parameters.
 
         Examples:
-            >>> ai = YEPCHAT(logging=True)
+            >>> ai = YEPCHAT()
             >>> ai.ask("What's the weather today?")
             Sends a prompt to the Yep API and returns the response.
 
@@ -85,7 +83,7 @@ class YEPCHAT(Provider):
             "Sec-CH-UA-Platform": '"Windows"',
             "User-Agent": self.agent.random(),  # Use LitAgent to generate a random user agent
         }
-        self.cookies = {"__Host-session": uuid.uuid4().hex}
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
 
         self.__available_optimizers = (
             method
@@ -106,9 +104,6 @@ class YEPCHAT(Provider):
 
         self.knowledge_cutoff = "December 2023"
 
-        # Initialize logger
-        self.logger = Logger(name="YEPCHAT", format=LogFormat.MODERN_EMOJI) if logging else None
-
     def ask(
         self,
         prompt: str,
@@ -128,9 +123,6 @@ class YEPCHAT(Provider):
             >>> ai.ask("Tell me a joke", stream=True)
             Streams the response from the Yep API.
         """
-        if self.logger:
-            self.logger.debug(f"ask() called with prompt: {prompt}")
-
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
@@ -138,8 +130,6 @@ class YEPCHAT(Provider):
                     conversation_prompt if conversationally else prompt
                 )
             else:
-                if self.logger:
-                    self.logger.error(f"Invalid optimizer: {optimizer}")
                 raise Exception(
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
@@ -157,8 +147,6 @@ class YEPCHAT(Provider):
             try:
                 with self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout) as response:
                     if not response.ok:
-                        if self.logger:
-                            self.logger.error(f"Failed to generate response: {response.status_code} {response.reason}")
                         raise exceptions.FailedToGenerateResponseError(
                             f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                         )
@@ -183,13 +171,9 @@ class YEPCHAT(Provider):
                                             resp = dict(text=content) 
                                             yield resp if raw else resp
                                 except json.JSONDecodeError:
-                                    if self.logger:
-                                        self.logger.warning("JSONDecodeError encountered.")
                                     pass
                     self.conversation.update_chat_history(prompt, streaming_text)
             except Exception as e:
-                if self.logger:
-                    self.logger.error(f"Request failed: {e}")
                 raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
 
         def for_non_stream():
@@ -217,9 +201,6 @@ class YEPCHAT(Provider):
             >>> ai.chat("What's the weather today?", stream=True)
             Streams the chat response from the Yep API.
         """
-        if self.logger:
-            self.logger.debug(f"chat() called with prompt: {prompt}")
-
         def for_stream():
             for response in self.ask(
                 prompt, True, optimizer=optimizer, conversationally=conversationally
@@ -255,8 +236,7 @@ class YEPCHAT(Provider):
 if __name__ == "__main__":
     from rich import print
 
-    ai = YEPCHAT(logging=False)
-
+    ai = YEPCHAT(model="DeepSeek-R1-Distill-Qwen-32B")
     response = ai.chat("how many r in 'strawberry'", stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)

webscout/__init__.py

@@ -17,6 +17,7 @@ from .swiftcli import *
 from .litagent import LitAgent
 from .scout import *
 from .zeroart import *
+from .yep_search import *
 agent = LitAgent()
 
 __repo__ = "https://github.com/OE-LUCIFER/Webscout"

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "7.2"
+__version__ = "7.4"
 __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
 
@@ -1140,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)