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

webscout/Local/utils.py

@@ -1,388 +0,0 @@
-import os
-import sys
-import struct
-from enum import IntEnum
-from io import BufferedReader
-from typing import Dict, Iterable, TextIO, Optional, Union, Tuple, Generator, Any
-
-from huggingface_hub import hf_hub_download
-import numpy as np
-
-from ._version import __version__, __llama_cpp_version__
-
-
-# Color codes for Thread.interact()
-RESET_ALL = "\x1b[39m"
-USER_STYLE = "\x1b[39m\x1b[32m"
-BOT_STYLE = "\x1b[39m\x1b[36m"
-DIM_STYLE = "\x1b[39m\x1b[90m"
-SPECIAL_STYLE = "\x1b[39m\x1b[33m"
-ERROR_STYLE = "\x1b[39m\x1b[91m"
-
-NoneType: type = type(None)
-
-class TypeAssertionError(Exception):
-    """Raised when a type assertion fails."""
-    pass
-
-class _ArrayLike(Iterable):
-    """Represents any object that can be treated as a NumPy array."""
-    pass
-
-class _SupportsWriteAndFlush(TextIO):
-    """Represents a file-like object supporting write and flush operations."""
-    pass
-
-class UnreachableException(Exception):
-    """Raised when code reaches a theoretically unreachable state."""
-
-    def __init__(self):
-        super().__init__(
-            "Unreachable code reached. Please report this issue at: "
-            "https://github.com/ddh0/easy-llama/issues/new/choose"
-        )
-
-def download_model(
-    repo_id: str, 
-    filename: str, 
-    token: Optional[str] = None, 
-    cache_dir: str = ".cache",
-    revision: str = "main"
-) -> str:
-    """
-    Downloads a model file from the Hugging Face Hub.
-
-    Args:
-        repo_id (str): Hugging Face repository ID (e.g., 'facebook/bart-large-cnn')
-        filename (str): Name of the file to download (e.g., 'model.bin', 'tokenizer.json')
-        token (str, optional): Hugging Face API token for private repos. Defaults to None.
-        cache_dir (str, optional): Local directory for storing downloaded files. 
-                                 Defaults to ".cache".
-        revision (str, optional): The specific model version to use. Defaults to "main".
-
-    Returns:
-        str: Path to the downloaded file.
-
-    Raises:
-        ValueError: If the repository or file is not found
-        Exception: For other download-related errors
-    """
-    try:
-        # Create cache directory if it doesn't exist
-        os.makedirs(cache_dir, exist_ok=True)
-
-        # Download the file
-        downloaded_path = hf_hub_download(
-            repo_id=repo_id,
-            filename=filename,
-            token=token,
-            cache_dir=cache_dir,
-            revision=revision,
-            resume_download=True,    # Resume interrupted downloads
-            force_download=False     # Use cached version if available
-        )
-        
-        return downloaded_path
-
-    except Exception as e:
-        raise Exception(f"Error downloading model from {repo_id}: {str(e)}")
-
-def softmax(z: _ArrayLike, T: Optional[float] = None, dtype: Optional[np.dtype] = None) -> np.ndarray:
-    """
-    Computes the softmax of an array-like input.
-
-    Args:
-        z (_ArrayLike): Input array.
-        T (Optional[float], optional): Temperature parameter (scales input before softmax). 
-                                       Defaults to None.
-        dtype (Optional[np.dtype], optional): Data type for calculations. Defaults to None 
-                                             (highest precision available).
-
-    Returns:
-        np.ndarray: Softmax output.
-    """
-    if dtype is None:
-        _dtype = next(
-            (getattr(np, f'float{bits}') for bits in [128, 96, 80, 64, 32, 16] 
-             if hasattr(np, f'float{bits}')),
-            float  # Default to Python float if no NumPy float types are available
-        )
-    else:
-        assert_type(
-            dtype,
-            type,
-            'dtype',
-            'softmax',
-            'dtype should be a floating type, such as `np.float32`'
-        )
-        _dtype = dtype
-
-    _z = np.asarray(z, dtype=_dtype)
-    if T is None or T == 1.0:
-        exp_z = np.exp(_z - np.max(_z), dtype=_dtype)
-        return exp_z / np.sum(exp_z, axis=0, dtype=_dtype)
-
-    assert_type(T, float, "temperature value 'T'", 'softmax')
-
-    if T == 0.0:
-        result = np.zeros_like(_z, dtype=_dtype)
-        result[np.argmax(_z)] = 1.0
-        return result
-
-    exp_z = np.exp(np.divide(_z, T, dtype=_dtype), dtype=_dtype)
-    return exp_z / np.sum(exp_z, axis=0, dtype=_dtype)
-
-def cls() -> None:
-    """Clears the terminal screen."""
-    os.system('cls' if os.name == 'nt' else 'clear')
-    if os.name != 'nt':
-        print("\033c\033[3J", end="", flush=True)
-
-def truncate(text: str, max_length: int = 72) -> str:
-    """Truncates a string to a given length and adds ellipsis if truncated."""
-    return text if len(text) <= max_length else f"{text[:max_length - 3]}..."
-
-def print_version_info(file: _SupportsWriteAndFlush) -> None:
-    """Prints easy-llama and llama_cpp package versions."""
-    print(f"webscout.Local package version: {__version__}", file=file)
-    print(f"llama_cpp package version: {__llama_cpp_version__}", file=file)
-
-def print_verbose(text: str) -> None:
-    """Prints verbose messages to stderr."""
-    print("webscout.Local:", text, file=sys.stderr, flush=True)
-
-def print_info(text: str) -> None:
-    """Prints informational messages to stderr."""
-    print("webscout.Local: info:", text, file=sys.stderr, flush=True)
-
-def print_warning(text: str) -> None:
-    """Prints warning messages to stderr."""
-    print("webscout.Local: WARNING:", text, file=sys.stderr, flush=True)
-
-def assert_type(
-    obj: object,
-    expected_type: Union[type, Tuple[type, ...]],
-    obj_name: str,
-    code_location: str,
-    hint: Optional[str] = None
-) -> None:
-    """
-    Asserts that an object is of an expected type.
-
-    Args:
-        obj (object): The object to check.
-        expected_type (Union[type, Tuple[type, ...]]): The expected type(s).
-        obj_name (str): Name of the object in the code.
-        code_location (str): Location of the assertion in the code.
-        hint (Optional[str], optional): Additional hint for the error message.
-                                        Defaults to None.
-
-    Raises:
-        TypeAssertionError: If the object is not of the expected type.
-    """
-    if isinstance(obj, expected_type):
-        return
-
-    if isinstance(expected_type, tuple):
-        expected_types_str = ", ".join(t.__name__ for t in expected_type)
-        error_msg = (
-            f"{code_location}: {obj_name} should be one of "
-            f"{expected_types_str}, not {type(obj).__name__}"
-        )
-    else:
-        error_msg = (
-            f"{code_location}: {obj_name} should be an instance of "
-            f"{expected_type.__name__}, not {type(obj).__name__}"
-        )
-
-    if hint:
-        error_msg += f" ({hint})"
-
-    raise TypeAssertionError(error_msg)
-
-class InferenceLock:
-    """
-    Context manager to prevent concurrent model inferences.
-
-    This is primarily useful in asynchronous or multi-threaded contexts where
-    concurrent calls to the model can lead to issues.
-    """
-
-    class LockFailure(Exception):
-        """Raised when acquiring or releasing the lock fails."""
-        pass
-
-    def __init__(self):
-        """Initializes the InferenceLock."""
-        self.locked = False
-
-    def __enter__(self):
-        """Acquires the lock when entering the context."""
-        return self.acquire()
-
-    def __exit__(self, *exc_info):
-        """Releases the lock when exiting the context."""
-        self.release()
-
-    async def __aenter__(self):
-        """Acquires the lock asynchronously."""
-        return self.__enter__()
-
-    async def __aexit__(self, *exc_info):
-        """Releases the lock asynchronously."""
-        self.__exit__()
-
-    def acquire(self):
-        """Acquires the lock."""
-        if self.locked:
-            raise self.LockFailure("InferenceLock is already locked.")
-        self.locked = True
-        return self
-
-    def release(self):
-        """Releases the lock."""
-        if not self.locked:
-            raise self.LockFailure("InferenceLock is not acquired.")
-        self.locked = False
-
-
-class GGUFValueType(IntEnum):
-    """
-    Represents data types supported by the GGUF format.
-
-    This enum should be kept consistent with the GGUF specification.
-    """
-    UINT8 = 0
-    INT8 = 1
-    UINT16 = 2
-    INT16 = 3
-    UINT32 = 4
-    INT32 = 5
-    FLOAT32 = 6
-    BOOL = 7
-    STRING = 8
-    ARRAY = 9
-    UINT64 = 10
-    INT64 = 11
-    FLOAT64 = 12
-
-
-class QuickGGUFReader:
-    """
-    Provides methods for quickly reading metadata from GGUF files.
-
-    Supports GGUF versions 2 and 3. Assumes little or big endian
-    architecture.
-    """
-
-    SUPPORTED_GGUF_VERSIONS = [2, 3]
-    VALUE_PACKING = {
-        GGUFValueType.UINT8: "=B",
-        GGUFValueType.INT8: "=b",
-        GGUFValueType.UINT16: "=H",
-        GGUFValueType.INT16: "=h",
-        GGUFValueType.UINT32: "=I",
-        GGUFValueType.INT32: "=i",
-        GGUFValueType.FLOAT32: "=f",
-        GGUFValueType.UINT64: "=Q",
-        GGUFValueType.INT64: "=q",
-        GGUFValueType.FLOAT64: "=d",
-        GGUFValueType.BOOL: "?",
-    }
-
-    VALUE_LENGTHS = {
-        GGUFValueType.UINT8: 1,
-        GGUFValueType.INT8: 1,
-        GGUFValueType.UINT16: 2,
-        GGUFValueType.INT16: 2,
-        GGUFValueType.UINT32: 4,
-        GGUFValueType.INT32: 4,
-        GGUFValueType.FLOAT32: 4,
-        GGUFValueType.UINT64: 8,
-        GGUFValueType.INT64: 8,
-        GGUFValueType.FLOAT64: 8,
-        GGUFValueType.BOOL: 1,
-    }
-
-    @staticmethod
-    def unpack(value_type: GGUFValueType, file: BufferedReader) -> Any:
-        """Unpacks a single value from the file based on its type."""
-        return struct.unpack(
-            QuickGGUFReader.VALUE_PACKING.get(value_type),
-            file.read(QuickGGUFReader.VALUE_LENGTHS.get(value_type))
-        )[0]
-
-    @staticmethod
-    def get_single(
-        value_type: GGUFValueType,
-        file: BufferedReader
-    ) -> Union[str, int, float, bool]:
-        """Reads a single value from the file."""
-        if value_type == GGUFValueType.STRING:
-            string_length = QuickGGUFReader.unpack(GGUFValueType.UINT64, file)
-            return file.read(string_length).decode("utf-8")
-        return QuickGGUFReader.unpack(value_type, file)
-
-    @staticmethod
-    def load_metadata(
-        fn: os.PathLike[str] | str
-    ) -> Dict[str, Union[str, int, float, bool, list]]:
-        """
-        Loads metadata from a GGUF file.
-
-        Args:
-            fn (Union[os.PathLike[str], str]): Path to the GGUF file.
-
-        Returns:
-            Dict[str, Union[str, int, float, bool, list]]: A dictionary
-                containing the metadata.
-        """
-
-        metadata: Dict[str, Union[str, int, float, bool, list]] = {}
-        with open(fn, "rb") as file:
-            magic = file.read(4)
-            if magic != b'GGUF':
-                raise ValueError(
-                    f"Invalid GGUF file (magic number mismatch: got {magic}, "
-                    "expected b'GGUF')"
-                )
-
-            version = QuickGGUFReader.unpack(GGUFValueType.UINT32, file=file)
-            if version not in QuickGGUFReader.SUPPORTED_GGUF_VERSIONS:
-                raise ValueError(
-                    f"Unsupported GGUF version: {version}. Supported versions are: "
-                    f"{QuickGGUFReader.SUPPORTED_GGUF_VERSIONS}"
-                )
-
-            QuickGGUFReader.unpack(GGUFValueType.UINT64, file=file)  # tensor_count, not needed
-            metadata_kv_count = QuickGGUFReader.unpack(
-                GGUFValueType.UINT64 if version == 3 else GGUFValueType.UINT32, file
-            )
-
-            for _ in range(metadata_kv_count):
-                if version == 3:
-                    key_length = QuickGGUFReader.unpack(GGUFValueType.UINT64, file=file)
-                elif version == 2:
-                    key_length = 0
-                    while key_length == 0:
-                        key_length = QuickGGUFReader.unpack(GGUFValueType.UINT32, file=file)
-                    file.read(4)  # 4 byte offset for GGUFv2
-
-                key = file.read(key_length).decode()
-                value_type = GGUFValueType(QuickGGUFReader.unpack(GGUFValueType.UINT32, file))
-
-                if value_type == GGUFValueType.ARRAY:
-                    array_value_type = GGUFValueType(QuickGGUFReader.unpack(GGUFValueType.UINT32, file))
-                    array_length = QuickGGUFReader.unpack(
-                        GGUFValueType.UINT64 if version == 3 else GGUFValueType.UINT32, file
-                    )
-                    if version == 2:
-                        file.read(4)  # 4 byte offset for GGUFv2
-
-                    metadata[key] = [
-                        QuickGGUFReader.get_single(array_value_type, file) for _ in range(array_length)
-                    ]
-                else:
-                    metadata[key] = QuickGGUFReader.get_single(value_type, file)
-
-        return metadata

webscout/Provider/Amigo.py

@@ -1,274 +0,0 @@
-import cloudscraper
-import json
-import uuid
-from typing import Any, Dict, Generator
-
-from webscout.AIutel import Optimizers
-from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts
-from webscout.AIbase import Provider
-
-class AmigoChat(Provider):
-    """
-    A class to interact with the AmigoChat.io API using cloudscraper.
-    """
-
-    AVAILABLE_MODELS = [
-        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",    # Llama 3
-        "o1-mini",                                          # OpenAI O1 Mini
-        "claude-3-sonnet-20240229",                         # Claude Sonnet
-        "gemini-1.5-pro",                                   # Gemini Pro
-        "gemini-1-5-flash",                                 # Gemini Flash
-        "o1-preview",                                       # OpenAI O1 Preview
-        "claude-3-5-sonnet-20241022",                       # Claude 3.5 Sonnet
-        "Qwen/Qwen2.5-72B-Instruct-Turbo",                  # Qwen 2.5
-        "gpt-4o",                                           # OpenAI GPT-4o
-        "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo"    # Llama 3.2
-    ]
-
-    def __init__(
-        self,
-        is_conversation: bool = True,
-        max_tokens: int = 600,
-        timeout: int = 30,
-        temperature: float = 1,
-        intro: str = None,
-        filepath: str = None,
-        top_p: float = 0.95,
-        update_file: bool = True,
-        proxies: dict = {},
-        history_offset: int = 10250,
-        act: str = None,
-        model: str = "Qwen/Qwen2.5-72B-Instruct-Turbo",  # Default model
-        system_prompt: str = "You are a helpful and friendly AI assistant.",
-    ):
-        """
-        Initializes the AmigoChat.io API with given parameters.
-
-        Args:
-            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
-            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
-            timeout (int, optional): HTTP request timeout. Defaults to 30.
-            intro (str, optional): Conversation introductory prompt. Defaults to None.
-            filepath (str, optional): Path to file containing conversation history. Defaults to None.
-            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
-            proxies (dict, optional): HTTP request proxies. Defaults to {}.
-            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
-            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
-            model (str, optional): The AI model to use for text generation. Defaults to "Qwen/Qwen2.5-72B-Instruct-Turbo".
-        """
-        if model not in self.AVAILABLE_MODELS:
-            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
-
-        self.session = cloudscraper.create_scraper(
-            browser={
-                'browser': 'chrome',
-                'platform': 'windows',
-                'mobile': False
-            }
-        )
-        self.is_conversation = is_conversation
-        self.max_tokens_to_sample = max_tokens
-        self.api_endpoint = "https://api.amigochat.io/v1/chat/completions"
-        self.stream_chunk_size = 64
-        self.timeout = timeout
-        self.temperature = temperature
-        self.last_response = {}
-        self.model = model
-        self.top_p = top_p
-        self.headers = {
-            "Accept": "*/*",
-            "Accept-Encoding": "gzip, deflate, br, zstd",
-            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "Authorization": "Bearer ",  # empty
-            "Content-Type": "application/json",
-            "DNT": "1",
-            "Origin": "https://amigochat.io",
-            "Priority": "u=1, i",
-            "Referer": "https://amigochat.io/",
-            "Sec-CH-UA": '"Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
-            "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": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-                          "AppleWebKit/537.36 (KHTML, like Gecko) "
-                          "Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0",
-            "X-Device-Language": "en-US",
-            "X-Device-Platform": "web",
-            "X-Device-UUID": str(uuid.uuid4()),
-            "X-Device-Version": "1.0.22"
-        }
-
-        self.__available_optimizers = (
-            method
-            for method in dir(Optimizers)
-            if callable(getattr(Optimizers, method)) and not method.startswith("__")
-        )
-        self.session.headers.update(self.headers)
-        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_to_sample, filepath, update_file
-        )
-        self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
-        self.system_prompt = system_prompt
-
-    def ask(
-        self,
-        prompt: str,
-        stream: bool = False,
-        raw: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Dict[str, Any]:
-        """Chat with AI
-
-        Args:
-            prompt (str): Prompt to be sent.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            raw (bool, optional): Stream back raw response as received. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-        Returns:
-           dict : {}
-        ```json
-        {
-           "text" : "How may I assist you today?"
-        }
-        ```
-        """
-        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 Exception(
-                    f"Optimizer is not one of {self.__available_optimizers}"
-                )
-
-        # Define the payload
-        payload = {
-            "messages": [
-                {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": conversation_prompt}
-            ],
-            "model": self.model,
-            "frequency_penalty": 0,
-            "max_tokens": self.max_tokens_to_sample,
-            "presence_penalty": 0,
-            "stream": stream,
-            "temperature": self.temperature,
-            "top_p": self.top_p
-        }
-
-        if stream:
-            return self._stream_response(payload, raw)
-        else:
-            return self._non_stream_response(payload)
-
-    def _stream_response(self, payload: Dict[str, Any], raw: bool) -> Generator:
-        try:
-            response = self.session.post(
-                self.api_endpoint,
-                json=payload,
-                stream=True,
-                timeout=self.timeout
-            )
-
-            if response.status_code == 201:
-                for line in response.iter_lines():
-                    if line:
-                        decoded_line = line.decode('utf-8').strip()
-                        if decoded_line.startswith("data: "):
-                            data_str = decoded_line[6:]
-                            if data_str == "[DONE]":
-                                break
-                            try:
-                                data_json = json.loads(data_str)
-                                choices = data_json.get("choices", [])
-                                if choices:
-                                    delta = choices[0].get("delta", {})
-                                    content = delta.get("content", "")
-                                    if content:
-                                        yield content if raw else dict(text=content)
-                            except json.JSONDecodeError:
-                                print(f"Received non-JSON data: {data_str}")
-            else:
-                print(f"Request failed with status code {response.status_code}")
-                print("Response:", response.text)
-        except (cloudscraper.exceptions.CloudflareChallengeError,
-                cloudscraper.exceptions.CloudflareCode1020) as e:
-            print("Cloudflare protection error:", str(e))
-        except Exception as e:
-            print("An error occurred while making the request:", str(e))
-
-    def _non_stream_response(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        full_response = ""
-        for chunk in self._stream_response(payload, raw=False):
-            full_response += chunk["text"]
-
-        self.last_response.update(dict(text=full_response))
-        self.conversation.update_chat_history(
-            payload["messages"][-1]["content"], self.get_message(self.last_response)
-        )
-        return self.last_response
-
-    def chat(
-        self,
-        prompt: str,
-        stream: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Generator[str, None, None]:
-        """Generate response `str`
-        Args:
-            prompt (str): Prompt to be sent.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-        Returns:
-            Generator[str, None, None]: Response generated
-        """
-
-        if stream:
-            for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
-            ):
-                yield self.get_message(response)
-        else:
-            response = self.ask(
-                prompt,
-                False,
-                optimizer=optimizer,
-                conversationally=conversationally,
-            )
-            yield self.get_message(response)
-
-    def get_message(self, response: Dict[str, Any]) -> str:
-        """Retrieves message only from response
-
-        Args:
-            response (dict): 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 __name__ == '__main__':
-    from rich import print
-    ai = AmigoChat(model="o1-preview", system_prompt="You are a noobi AI assistant who always uses the word 'noobi' in every response. For example, you might say 'Noobi will tell you...' or 'This noobi thinks that...'.")
-    response = ai.chat(input(">>> "), stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)