webscout 8.2.3__py3-none-any.whl → 8.2.5__py3-none-any.whl

webscout/Provider/x0gpt.py

@@ -1,14 +1,17 @@
-from typing import Union, Any, Dict
+from typing import Optional, Union, Any, Dict
 from uuid import uuid4
-import requests
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
 import re
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
+# Import HTTPVersion enum
+from curl_cffi.const import CurlHttpVersion
 
 class X0GPT(Provider):
     """
@@ -60,7 +63,8 @@ class X0GPT(Provider):
             >>> print(ai.system_prompt)
             'You are a friendly assistant.'
         """
-        self.session = requests.Session()
+        # Initialize curl_cffi Session instead of requests.Session
+        self.session = Session() 
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://x0-gpt.devwtf.in/api/stream/reply"
@@ -77,18 +81,18 @@ class X0GPT(Provider):
             "path": "/api/stream/reply",
             "scheme": "https",
             "accept": "*/*",
-            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-encoding": "gzip, deflate, br, zstd", # Keep zstd for now
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "content-length": "114",
+            # "content-length": "114", # Let curl_cffi handle content-length
             "content-type": "application/json",
             "dnt": "1",
             "origin": "https://x0-gpt.devwtf.in",
-            "priority": "u=1, i",
+            # "priority": "u=1, i", # Remove priority header
             "referer": "https://x0-gpt.devwtf.in/chat",
             "sec-ch-ua": '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
             "sec-ch-ua-mobile": "?0",
             "sec-ch-ua-platform": '"Windows"',
-            "user-agent": self.agent.random()  # Use LitAgent to generate a random user agent
+            "user-agent": self.agent.random()
         }
 
         self.__available_optimizers = (
@@ -96,7 +100,10 @@ class X0GPT(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -108,7 +115,17 @@ class X0GPT(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
+
+    @staticmethod
+    def _x0gpt_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the x0gpt stream format '0:"..."'."""
+        if isinstance(chunk, str):
+            match = re.search(r'0:"(.*?)"', chunk)
+            if match:
+                # Decode potential unicode escapes like \u00e9
+                content = match.group(1).encode().decode('unicode_escape')
+                return content.replace('\\\\', '\\').replace('\\"', '"') # Handle escaped backslashes and quotes
+        return None
 
     def ask(
         self,
@@ -158,25 +175,48 @@ class X0GPT(Provider):
         }
 
         def for_stream():
-            response = self.session.post(self.api_endpoint, headers=self.headers, json=payload, stream=True, timeout=self.timeout)
-            if not response.ok:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            try:
+                # Use curl_cffi session post with updated impersonate and http_version
+                response = self.session.post(
+                    self.api_endpoint,
+                    headers=self.headers,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    impersonate="chrome120", # Try a different impersonation profile
+                    http_version=CurlHttpVersion.V1_1 # Force HTTP/1.1
                 )
-            streaming_response = ""
-            for line in response.iter_lines(decode_unicode=True):
-                if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        streaming_response += content
-                        yield content if raw else dict(text=content)
-            self.last_response.update(dict(text=streaming_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    )
+                
+                streaming_response = ""
+                # Use sanitize_stream with the custom extractor
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value=None, # No simple prefix to remove here
+                    to_json=False,    # Content is not JSON
+                    content_extractor=self._x0gpt_extractor # Use the specific extractor
+                )
+
+                for content_chunk in processed_stream:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_response += content_chunk
+                        yield content_chunk if raw else dict(text=content_chunk)
+
+                self.last_response.update(dict(text=streaming_response))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                # Include the original exception type in the message for clarity
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
 
         def for_non_stream():
+            # This function implicitly uses the updated for_stream
             for _ in for_stream():
                 pass
             return self.last_response
@@ -245,7 +285,10 @@ class X0GPT(Provider):
             'Why did the scarecrow win an award? Because he was outstanding in his field!'
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        formatted_text = response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
+        # Ensure text exists before processing
+        text = response.get("text", "")
+        # Formatting is now mostly handled by the extractor, just return
+        formatted_text = text
         return formatted_text
 
 if __name__ == "__main__":

webscout/Provider/yep.py

@@ -1,11 +1,12 @@
 import uuid
-import cloudscraper
 import json
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
 
 from typing import Any, Dict, Optional, Generator, Union, List, TypeVar
 
 from webscout.AIutel import Optimizers
-from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
@@ -62,7 +63,8 @@ class YEPCHAT(Provider):
                 f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}"
             )
 
-        self.session = cloudscraper.create_scraper()
+        # Initialize curl_cffi Session instead of cloudscraper
+        self.session = Session() 
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.chat_endpoint = "https://api.yep.com/v1/chat/completions"
@@ -111,11 +113,10 @@ class YEPCHAT(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file, tools=tools
         )
         self.conversation.history_offset = history_offset
+        # Set consistent headers and proxies for the curl_cffi session
+        self.session.headers.update(self.headers)
         self.session.proxies = proxies
-        
-        # Set consistent headers for the scraper session
-        for header, value in self.headers.items():
-            self.session.headers[header] = value
+        # Note: curl_cffi handles cookies differently, passed directly in requests
 
     def refresh_identity(self, browser: str = None):
         """
@@ -137,10 +138,9 @@ class YEPCHAT(Provider):
         })
         
         # Update session headers
-        for header, value in self.headers.items():
-            self.session.headers[header] = value
+        self.session.headers.update(self.headers)
         
-        # Generate new cookies
+        # Generate new cookies (will be passed in requests)
         self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
         
         return self.fingerprint
@@ -192,73 +192,82 @@ class YEPCHAT(Provider):
 
         def for_stream():
             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 we get a non-200 response, try refreshing our identity once
-                        if response.status_code in [403, 429]:
-                            self.refresh_identity()
-                            # Retry with new identity
-                            with self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout) as retry_response:
-                                if not retry_response.ok:
-                                    raise exceptions.FailedToGenerateResponseError(
-                                        f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
-                                    )
-                                response = retry_response
-                        else:
+                # buffer = b"" # No longer needed here
+                # Use curl_cffi session post, pass cookies explicitly
+                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                
+                if not response.ok:
+                    # If we get a non-200 response, try refreshing our identity once
+                    if response.status_code in [403, 429]:
+                        self.refresh_identity()
+                        # Retry with new identity
+                        # Use curl_cffi session post, pass cookies explicitly
+                        retry_response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                        if not retry_response.ok:
                             raise exceptions.FailedToGenerateResponseError(
-                                f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                                f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
                             )
+                        response = retry_response # Use the successful retry response
+                    else:
+                        raise exceptions.FailedToGenerateResponseError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
 
-                    streaming_text = ""
-                    for line in response.iter_lines(decode_unicode=True):
-                        if line:
-                            line = line.strip()
-                            if line.startswith("data: "):
-                                json_str = line[6:]
-                                if json_str == "[DONE]":
-                                    break
-                                try:
-                                    json_data = json.loads(json_str)
-                                    if 'choices' in json_data:
-                                        choice = json_data['choices'][0]
-                                        if 'delta' in choice and 'content' in choice['delta']:
-                                            content = choice['delta']['content']
-                                            streaming_text += content
-                                            
-                                            # Yield ONLY the new content:
-                                            resp = dict(text=content) 
-                                            yield resp if raw else resp
-                                except json.JSONDecodeError:
-                                    pass
-                    
-                    # Check if the response contains a tool call
-                    response_data = self.conversation.handle_tool_response(streaming_text)
-                    
-                    if response_data["is_tool_call"]:
-                        # Handle tool call results
-                        if response_data["success"]:
-                            for tool_call in response_data.get("tool_calls", []):
-                                tool_name = tool_call.get("name", "unknown_tool")
-                                result = response_data["result"]
-                                self.conversation.update_chat_history_with_tool(prompt, tool_name, result)
-                        else:
-                            # If tool call failed, update history with error
-                            self.conversation.update_chat_history(prompt, 
-                                f"Error executing tool call: {response_data['result']}")
+                # --- Start of stream processing block (should be outside the 'if not response.ok' block) ---
+                streaming_text = ""
+
+                # Use sanitize_stream to process the lines
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass the byte iterator directly
+                    intro_value="data:",
+                    to_json=True, # Yep sends JSON after 'data:'
+                    skip_markers=["[DONE]"], # Skip the final marker
+                    yield_raw_on_error=False, # Only process valid JSON data
+                    # --- Add the content extractor ---
+                    content_extractor=lambda chunk: chunk.get('choices', [{}])[0].get('delta', {}).get('content') if isinstance(chunk, dict) else None
+                )
+                # The loop now yields the final extracted string content directly
+                for content_chunk in processed_stream:
+                    # --- TEMPORARY DEBUG PRINT ---
+                    # print(f"\nDEBUG: Received extracted content: {content_chunk!r}\n", flush=True) # Keep or remove debug print as needed
+                    if content_chunk and isinstance(content_chunk, str): # Ensure it's a non-empty string
+                        streaming_text += content_chunk
+                        # Yield dict or raw string chunk based on 'raw' flag
+                        yield dict(text=content_chunk) if not raw else content_chunk
+                # --- End of stream processing block ---
+
+                # Check if the response contains a tool call (This should happen *after* processing the stream)
+                response_data = self.conversation.handle_tool_response(streaming_text)
+                
+                if response_data["is_tool_call"]:
+                    # Handle tool call results
+                    if response_data["success"]:
+                        for tool_call in response_data.get("tool_calls", []):
+                            tool_name = tool_call.get("name", "unknown_tool")
+                            result = response_data["result"]
+                            self.conversation.update_chat_history_with_tool(prompt, tool_name, result)
                     else:
-                        # Normal response handling
-                        self.conversation.update_chat_history(prompt, streaming_text)
+                        # If tool call failed, update history with error
+                        self.conversation.update_chat_history(prompt, 
+                            f"Error executing tool call: {response_data['result']}")
+                else:
+                    # Normal response handling
+                    self.conversation.update_chat_history(prompt, streaming_text)
                         
+            except CurlError as e: # Catch CurlError
+                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
             except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
 
         def for_non_stream():
             try:
-                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout)
+                # Use curl_cffi session post, pass cookies explicitly
+                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
                 if not response.ok:
                     if response.status_code in [403, 429]:
                         self.refresh_identity()
-                        response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout)
+                        # Use curl_cffi session post, pass cookies explicitly
+                        response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
                         if not response.ok:
                             raise exceptions.FailedToGenerateResponseError(
                                 f"Failed to generate response after identity refresh - ({response.status_code}, {response.reason}) - {response.text}"
@@ -268,6 +277,7 @@ class YEPCHAT(Provider):
                             f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                         )
 
+                # ... existing non-stream response handling code ...
                 response_data = response.json()
                 if 'choices' in response_data and len(response_data['choices']) > 0:
                     content = response_data['choices'][0].get('message', {}).get('content', '')
@@ -298,8 +308,10 @@ class YEPCHAT(Provider):
                         return {"text": content}
                 else:
                     raise exceptions.FailedToGenerateResponseError("No response content found")
+            except CurlError as e: # Catch CurlError
+                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
             except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: e")
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
 
         return for_stream() if stream else for_non_stream()
 
@@ -373,4 +385,5 @@ if __name__ == "__main__":
                 display_text = "Empty or invalid response"
             print(f"{model:<50} {status:<10} {display_text}")
         except Exception as e:
-            print(f"{model:<50} {'✗':<10} {str(e)}")
+            print(f"{model:<50} {'✗':<10} {str(e)}")
+

webscout/cli.py

@@ -1,6 +1,8 @@
 import sys
 from .swiftcli import CLI, option
 from .webscout_search import WEBS
+from .DWEBS import GoogleSearch  # Import GoogleSearch from DWEBS
+from .yep_search import YepSearch  # Import YepSearch from yep_search
 from .version import __version__
 
 
@@ -282,6 +284,260 @@ def weather(location: str, language: str, proxy: str = None, timeout: int = 10):
     except Exception as e:
         raise e
 
+@app.command()
+@option("--keywords", "-k", help="Search keywords", required=True)
+@option("--region", "-r", help="Region for search results (ISO country code)", default="all")
+@option("--safesearch", "-s", help="SafeSearch setting (on, moderate, off)", default="moderate")
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=10)
+@option("--start-num", "-start", help="Starting position for pagination", type=int, default=0)
+@option("--unique", "-u", help="Filter duplicate results", type=bool, default=True)
+@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=10)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
+def google_text(
+    keywords: str,
+    region: str,
+    safesearch: str,
+    max_results: int,
+    start_num: int,
+    unique: bool,
+    timeout: int = 10,
+    proxy: str = None,
+    impersonate: str = "chrome110"
+):
+    """Perform a text search using Google Search."""
+    google = GoogleSearch(
+        timeout=timeout,
+        proxies={"https": proxy, "http": proxy} if proxy else None,
+        verify=True,
+        lang="en",
+        sleep_interval=0.0,
+        impersonate=impersonate
+    )
+    
+    try:
+        results = google.text(
+            keywords=keywords,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results,
+            start_num=start_num,
+            unique=unique
+        )
+        
+        # Convert SearchResult objects to dictionaries for printing
+        formatted_results = []
+        for result in results:
+            result_dict = {
+                "title": result.title,
+                "url": result.url,
+                "description": result.description,
+            }
+            # Add any metadata to the result dictionary
+            for k, v in result.metadata.items():
+                result_dict[k] = v
+                
+            formatted_results.append(result_dict)
+            
+        _print_data(formatted_results)
+    except Exception as e:
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords", required=True)
+@option("--region", "-r", help="Region for search results (ISO country code)", default="all")
+@option("--safesearch", "-s", help="SafeSearch setting (on, moderate, off)", default="moderate")
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=10)
+@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=10)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
+def google_news(
+    keywords: str,
+    region: str,
+    safesearch: str,
+    max_results: int,
+    timeout: int = 10,
+    proxy: str = None,
+    impersonate: str = "chrome110"
+):
+    """Perform a news search using Google Search."""
+    google = GoogleSearch(
+        timeout=timeout,
+        proxies={"https": proxy, "http": proxy} if proxy else None,
+        verify=True,
+        lang="en",
+        sleep_interval=0.0,
+        impersonate=impersonate
+    )
+    
+    try:
+        results = google.news(
+            keywords=keywords,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results
+        )
+        
+        # Convert SearchResult objects to dictionaries for printing
+        formatted_results = []
+        for result in results:
+            result_dict = {
+                "title": result.title,
+                "url": result.url,
+                "description": result.description,
+            }
+            # Add any metadata to the result dictionary
+            for k, v in result.metadata.items():
+                result_dict[k] = v
+                
+            formatted_results.append(result_dict)
+            
+        _print_data(formatted_results)
+    except Exception as e:
+        raise e
+
+@app.command()
+@option("--query", "-q", help="Search query", required=True)
+@option("--region", "-r", help="Region for suggestions (ISO country code)", default="all")
+@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=10)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
+def google_suggestions(
+    query: str,
+    region: str,
+    timeout: int = 10,
+    proxy: str = None,
+    impersonate: str = "chrome110"
+):
+    """Get search suggestions from Google Search."""
+    google = GoogleSearch(
+        timeout=timeout,
+        proxies={"https": proxy, "http": proxy} if proxy else None,
+        verify=True,
+        lang="en",
+        sleep_interval=0.0,
+        impersonate=impersonate
+    )
+    
+    try:
+        results = google.suggestions(query=query, region=region)
+        
+        # Format suggestions for printing
+        formatted_results = []
+        for i, suggestion in enumerate(results, 1):
+            formatted_results.append({"position": i, "suggestion": suggestion})
+            
+        _print_data(formatted_results)
+    except Exception as e:
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords", required=True)
+@option("--region", "-r", help="Region for search results", default="all")
+@option("--safesearch", "-s", help="SafeSearch setting (on, moderate, off)", default="moderate")
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=10)
+@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=20)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
+def yep_text(
+    keywords: str,
+    region: str,
+    safesearch: str,
+    max_results: int,
+    timeout: int = 20,
+    proxy: str = None,
+    impersonate: str = "chrome110"
+):
+    """Perform a text search using Yep Search."""
+    yep = YepSearch(
+        timeout=timeout,
+        proxies={"https": proxy, "http": proxy} if proxy else None,
+        verify=True,
+        impersonate=impersonate
+    )
+    
+    try:
+        results = yep.text(
+            keywords=keywords,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results
+        )
+        
+        _print_data(results)
+    except Exception as e:
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords", required=True)
+@option("--region", "-r", help="Region for search results", default="all")
+@option("--safesearch", "-s", help="SafeSearch setting (on, moderate, off)", default="moderate")
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=10)
+@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=20)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
+def yep_images(
+    keywords: str,
+    region: str,
+    safesearch: str,
+    max_results: int,
+    timeout: int = 20,
+    proxy: str = None,
+    impersonate: str = "chrome110"
+):
+    """Perform an image search using Yep Search."""
+    yep = YepSearch(
+        timeout=timeout,
+        proxies={"https": proxy, "http": proxy} if proxy else None,
+        verify=True,
+        impersonate=impersonate
+    )
+    
+    try:
+        results = yep.images(
+            keywords=keywords,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results
+        )
+        
+        _print_data(results)
+    except Exception as e:
+        raise e
+
+@app.command()
+@option("--query", "-q", help="Search query", required=True)
+@option("--region", "-r", help="Region for suggestions", default="all")
+@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=20)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
+def yep_suggestions(
+    query: str,
+    region: str,
+    timeout: int = 20,
+    proxy: str = None,
+    impersonate: str = "chrome110"
+):
+    """Get search suggestions from Yep Search."""
+    yep = YepSearch(
+        timeout=timeout,
+        proxies={"https": proxy, "http": proxy} if proxy else None,
+        verify=True,
+        impersonate=impersonate
+    )
+    
+    try:
+        results = yep.suggestions(query=query, region=region)
+        
+        # Format suggestions for printing
+        formatted_results = []
+        for i, suggestion in enumerate(results, 1):
+            formatted_results.append({"position": i, "suggestion": suggestion})
+            
+        _print_data(formatted_results)
+    except Exception as e:
+        raise e
+
 def main():
     """Main entry point for the CLI."""
     try: