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

webscout/Extra/autocoder/autocoder.py

@@ -7,19 +7,16 @@ import queue
 import tempfile
 import threading
 import subprocess
+from typing import Optional, Generator, List, Tuple, Dict, Any, NamedTuple
 from rich.panel import Panel
 from rich.syntax import Syntax
-from rich.console import Console, Group
+from rich.console import Console
 from rich.markdown import Markdown
 from rich.table import Table
 from rich.theme import Theme
 from rich.live import Live
-from rich.rule import Rule
 from rich.box import ROUNDED
-from typing import Optional, Generator, List, Tuple, Dict, Any
-from webscout.AIutel import run_system_command
 from .autocoder_utiles import get_intro_prompt
-
 # Initialize LitLogger with custom format and colors 
 default_path = tempfile.mkdtemp(prefix="webscout_autocoder")
 
@@ -34,6 +31,70 @@ CUSTOM_THEME = Theme({
 })
 
 console = Console(theme=CUSTOM_THEME)
+class CommandResult(NamedTuple):
+    """Result of a system command execution."""
+    success: bool
+    stdout: str
+    stderr: str
+    
+def run_system_command(
+    command: str,
+    exit_on_error: bool = False,
+    stdout_error: bool = False,
+    help: Optional[str] = None
+) -> Tuple[bool, CommandResult]:
+    """Execute a system command and return the result.
+    
+    Args:
+        command (str): Command to execute
+        exit_on_error (bool): Whether to exit on error. Defaults to False.
+        stdout_error (bool): Whether to include stdout in error messages. Defaults to False.
+        help (str, optional): Help message for errors. Defaults to None.
+        
+    Returns:
+        Tuple[bool, CommandResult]: Success status and command result containing stdout/stderr
+    """
+    try:
+        # Execute command and capture output
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            text=True
+        )
+        
+        # Get stdout and stderr
+        stdout, stderr = process.communicate()
+        success = process.returncode == 0
+        
+        # Create result object
+        result = CommandResult(
+            success=success,
+            stdout=stdout.strip() if stdout else "",
+            stderr=stderr.strip() if stderr else ""
+        )
+        
+        # Handle errors if needed
+        if not success and exit_on_error:
+            error_msg = stderr if stderr else stdout if stdout_error else "Command failed"
+            if help:
+                error_msg += f"\n{help}"
+            sys.exit(error_msg)
+            
+        return success, result
+        
+    except Exception as e:
+        # Handle execution errors
+        error_msg = str(e)
+        if help:
+            error_msg += f"\n{help}"
+            
+        if exit_on_error:
+            sys.exit(error_msg)
+            
+        return False, CommandResult(success=False, stdout="", stderr=error_msg)
+
 
 class AutoCoder:
     """Generate and auto-execute Python scripts in the CLI with advanced error handling and retry logic.

webscout/Provider/AISEARCH/scira_search.py

@@ -70,7 +70,8 @@ class Scira(AISearch):
 
     AVAILABLE_MODELS = {
         "scira-default": "Grok3-mini", # thinking model
-        "scira-grok-3": "Grok3", 
+        "scira-grok-3": "Grok3",
+        "scira-anthropic": "Sonnet 3.7 thinking",
         "scira-vision" : "Grok2-Vision", # vision model
         "scira-4.1-mini": "GPT4.1-mini",
         "scira-qwq": "QWQ-32B",

webscout/Provider/GizAI.py

@@ -264,12 +264,12 @@ class GizAI(Provider):
         )
         return self.get_message(response_data)
     
-    def get_message(self, response: dict) -> str:
+    def get_message(self, response: Union[dict, str]) -> str:
         """
         Extracts the message from the API response.
         
         Args:
-            response (dict): The API response.
+            response (Union[dict, str]): The API response.
             
         Returns:
             str: The message content.
@@ -279,5 +279,7 @@ class GizAI(Provider):
             >>> response = ai.ask("Tell me a joke!")
             >>> message = ai.get_message(response)
         """
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response.get("text", "")
+        if isinstance(response, str):
+            return response
+        assert isinstance(response, dict), "Response should be either dict or str"
+        return response.get("text", "")

webscout/Provider/Nemotron.py

@@ -0,0 +1,218 @@
+import requests
+import json
+import random
+import datetime
+from typing import Any, Dict, Optional, Union, Generator
+from webscout.AIutel import Optimizers, Conversation, AwesomePrompts, sanitize_stream
+from webscout.AIbase import Provider
+from webscout import exceptions
+
+class NEMOTRON(Provider):
+    """NEMOTRON provider for interacting with the nemotron.one API."""
+    url = "https://nemotron.one/api/chat"
+
+    AVAILABLE_MODELS = [
+        "gpt4o",
+        "nemotron70b",
+    ]
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 8000,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "gpt4o"
+    ):
+        """Initialize NEMOTRON with configuration options."""
+        self.session = requests.Session()
+        self.max_tokens = max_tokens
+        self.is_conversation = is_conversation
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = self.get_model(model)
+
+        self.headers = {
+            "authority": "nemotron.one",
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9",
+            "content-type": "application/json",
+            "origin": "https://nemotron.one",
+            "referer": f"https://nemotron.one/chat/{self.model}",
+            "sec-ch-ua": '"Chromium";v="136", "Not.A/Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36"
+        }
+
+        self.__available_optimizers = (
+            method for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    @staticmethod
+    def _generate_random_email() -> str:
+        """Generate a random email address."""
+        random_letter = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+        random_string = ''.join(random.choice(random_letter) for _ in range(10))
+        return f"{random_string}@gmail.com"
+
+    @staticmethod
+    def _generate_random_id() -> str:
+        """Generate a random user ID."""
+        timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S%f")
+        random_letter = "abcdefghijklmnopqrstuvwxyz0123456789"
+        random_string = ''.join(random.choice(random_letter) for _ in range(8))
+        return f"cm{random_string}{timestamp[:10]}"
+
+    @classmethod
+    def get_model(cls, model: str) -> str:
+        """Resolve model name from alias."""
+        if model in cls.AVAILABLE_MODELS:
+            return model  # Simply return the model name if it's in the list
+        raise ValueError(f"Unknown model: {model}. Available models: {', '.join(cls.AVAILABLE_MODELS)}")
+
+    def _get_user_data(self) -> Dict[str, Any]:
+        """Generate user data for the request."""
+        current_time = datetime.datetime.now().isoformat()
+        return {
+            "name": "user",
+            "email": self._generate_random_email(),
+            "image": "https://lh3.googleusercontent.com/a/default-user=s96-c",
+            "id": self._generate_random_id(),
+            "password": None,
+            "emailVerified": None,
+            "credits": 100000000000,
+            "isPro": False,
+            "createdAt": current_time,
+            "updatedAt": current_time
+        }
+
+    def _make_request(
+        self,
+        message: str,
+        stream: bool = False
+    ) -> Generator[str, None, None]:
+        """Make request to NEMOTRON API."""
+        payload = {
+            "content": message,
+            "imageSrc": "",
+            "model": self.model,
+            "user": self._get_user_data(),
+            "conversationId": ""
+        }
+
+        try:
+            if stream:
+                with self.session.post(
+                    self.url,
+                    headers=self.headers,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout
+                ) as response:
+                    response.raise_for_status()
+                    yield from sanitize_stream(
+                        response.iter_content(chunk_size=1024),
+                        to_json=False,
+                    )
+            else:
+                response = self.session.post(
+                    self.url,
+                    headers=self.headers,
+                    json=payload,
+                    timeout=self.timeout
+                )
+                response.raise_for_status()
+                yield response.text
+
+        except requests.exceptions.RequestException as e:
+            raise exceptions.ProviderConnectionError(f"Connection error: {str(e)}")
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, str], Generator[Dict[str, str], None, None]]:
+        """Send a prompt to NEMOTRON API and return the response."""
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise ValueError(f"Optimizer is not one of {self.__available_optimizers}")
+
+        def for_stream():
+            for text in self._make_request(conversation_prompt, stream=True):
+                yield {"text": text}
+
+        def for_non_stream():
+            response_text = next(self._make_request(conversation_prompt, stream=False))
+            self.last_response = {"text": response_text}
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        """Generate response as string."""
+        def for_stream():
+            for response in self.ask(
+                prompt,
+                stream=True,
+                optimizer=optimizer,
+                conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    stream=False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: Dict[str, Any]) -> str:
+        """Extract message from response dictionary."""
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+if __name__ == "__main__":
+    # Example usage
+    nemotron = NEMOTRON()
+    response = nemotron.chat("Hello, how are you?", stream=False)
+    print(response)

webscout/Provider/OPENAI/scirachat.py

@@ -325,7 +325,8 @@ class SciraChat(OpenAICompatibleProvider):
     
     AVAILABLE_MODELS = {
         "scira-default": "Grok3-mini", # thinking model
-        "scira-grok-3": "Grok3", 
+        "scira-grok-3": "Grok3",
+        "scira-anthropic": "Sonnet 3.7 thinking",
         "scira-vision" : "Grok2-Vision", # vision model
         "scira-4.1-mini": "GPT4.1-mini",
         "scira-qwq": "QWQ-32B",

webscout/Provider/TeachAnything.py

@@ -191,17 +191,20 @@ class TeachAnything(Provider):
             # If stream=False, return the full message directly
             return self.get_message(response_data)
 
-    def get_message(self, response: dict) -> str:
+    def get_message(self, response: Union[dict, str]) -> str:
         """Retrieves message only from response
 
         Args:
-            response (dict): Response generated by `self.ask`
+            response (Union[dict, str]): Response generated by `self.ask`
 
         Returns:
             str: Message extracted
         """
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        if isinstance(response, str):
+            return response
+        elif isinstance(response, dict):
+            return response["text"]
+        raise ValueError("Response must be either dict or str")
 
 
 if __name__ == '__main__':
@@ -227,4 +230,4 @@ if __name__ == '__main__':
     except exceptions.FailedToGenerateResponseError as e:
         print(f"\n[bold red]API Error:[/bold red] {e}")
     except Exception as e:
-        print(f"\n[bold red]An unexpected error occurred:[/bold red] {e}")
+        print(f"\n[bold red]An unexpected error occurred:[/bold red] {e}")

webscout/Provider/WiseCat.py

@@ -33,7 +33,7 @@ class WiseCat(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        model: str = "chat-model-large",
+        model: str = "chat-model-small",
         system_prompt: str = "You are a helpful AI assistant."
     ):
         """Initializes the WiseCat API client."""