webscout 6.3__py3-none-any.whl → 6.5__py3-none-any.whl

webscout/Bing_search.py

@@ -1,154 +0,0 @@
-from bs4 import BeautifulSoup
-import requests
-from typing import Dict, List, Optional, Union
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from urllib.parse import quote, urlparse, parse_qs
-import base64
-import urllib3
-
-# Disable SSL warnings
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-class BingS:
-    """Bing search class to get search results from bing.com."""
-
-    _executor: ThreadPoolExecutor = ThreadPoolExecutor(max_workers=10)
-
-    def __init__(
-        self,
-        headers: Optional[Dict[str, str]] = None,
-        proxy: Optional[str] = None,
-        timeout: Optional[int] = 10,
-    ) -> None:
-        """Initialize the BingS object."""
-        self.proxy: Optional[str] = proxy
-        self.headers = headers if headers else {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-        }
-        self.headers["Referer"] = "https://www.bing.com/"
-        self.client = requests.Session()
-        self.client.headers.update(self.headers)
-        self.client.proxies.update({"http": self.proxy, "https": self.proxy})
-        self.timeout = timeout
-
-    def __enter__(self) -> "BingS":
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.client.close()
-
-    def _get_url(
-        self,
-        method: str,
-        url: str,
-        params: Optional[Dict[str, str]] = None,
-        data: Optional[Union[Dict[str, str], bytes]] = None,
-    ) -> bytes:
-        try:
-            resp = self.client.request(method, url, params=params, data=data, timeout=self.timeout, verify=False)
-        except Exception as ex:
-            raise Exception(f"{url} {type(ex).__name__}: {ex}") from ex
-        if resp.status_code == 200:
-            return resp.content
-        raise Exception(f"{resp.url} returned status code {resp.status_code}. {params=} {data=}")
-
-    def extract_text_from_webpage(self, html_content, max_characters=None):
-        """Extracts visible text from HTML content using BeautifulSoup."""
-        soup = BeautifulSoup(html_content, "html.parser")
-        # Remove unwanted tags
-        for tag in soup(["script", "style", "header", "footer", "nav"]):
-            tag.extract()
-        # Get the remaining visible text
-        visible_text = soup.get_text(separator=' ', strip=True)
-        if max_characters:
-            visible_text = visible_text[:max_characters]
-        return visible_text
-
-    def search(
-        self,
-        keywords: str,
-        max_results: Optional[int] = 10,
-        extract_webpage_text: bool = False,
-        max_extract_characters: Optional[int] = 100,
-    ) -> List[Dict[str, str]]:
-        """Bing text search."""
-        assert keywords, "keywords is mandatory"
-
-        results = []
-        futures = []
-        start = 1
-        while len(results) < max_results:
-            params = {
-                "q": keywords,
-                "first": start
-            }
-            futures.append(self._executor.submit(self._get_url, "GET", "https://www.bing.com/search", params=params))
-            start += 10
-
-            for future in as_completed(futures):
-                try:
-                    resp_content = future.result()
-                    soup = BeautifulSoup(resp_content, "html.parser")
-                    result_block = soup.select('li.b_algo')
-
-                    if not result_block:
-                        break
-
-                    for result in result_block:
-                        try:
-                            link = result.select_one('h2 a')
-                            title = link.text if link else ""
-                            url = link['href'] if link else ""
-                            abstract = result.select_one('.b_caption p')
-                            description = abstract.text if abstract else ""
-
-                            # Remove "WEB" from the beginning of the description if it exists
-                            if description.startswith("WEB"):
-                                description = description[3:].strip()
-
-                            visible_text = ""
-                            if extract_webpage_text:
-                                try:
-                                    actual_url = self._decode_bing_url(url)
-                                    page_content = self._get_url("GET", actual_url)
-                                    visible_text = self.extract_text_from_webpage(
-                                        page_content, max_characters=max_extract_characters
-                                    )
-                                except Exception as e:
-                                    print(f"Error extracting text from {url}: {e}")
-
-                            results.append({
-                                "title": title,
-                                "href": url,
-                                "abstract": description,
-                                "index": len(results),
-                                "type": "web",
-                                "visible_text": visible_text,
-                            })
-
-                            if len(results) >= max_results:
-                                return results
-
-                        except Exception as e:
-                            print(f"Error extracting result: {e}")
-
-                except Exception as e:
-                    print(f"Error fetching URL: {e}")
-
-        return results
-
-    def _decode_bing_url(self, url):
-        if 'bing.com/ck/a' in url:
-            parsed_url = urlparse(url)
-            query_params = parse_qs(parsed_url.query)
-            if 'u' in query_params:
-                encoded_url = query_params['u'][0]
-                return base64.b64decode(encoded_url).decode('utf-8')
-        return url
-
-if __name__ == "__main__":
-    from rich import print
-    searcher = BingS()
-    results = searcher.search("Python development tools", max_results=5, extract_webpage_text=True, max_extract_characters=2000)
-    for result in results:
-        print(result)

webscout/Provider/TTI/AIuncensoredimage.py

@@ -1,103 +0,0 @@
-import requests
-import json
-import os
-from datetime import datetime
-from typing import List, Dict, Optional
-
-from webscout.AIbase import ImageProvider
-from webscout import exceptions
-
-
-class AIUncensoredImager(ImageProvider):
-    """
-    Image provider for AIUncensored.info.
-    """
-
-    def __init__(self, timeout: int = 60, proxies: dict = {}):
-        """Initializes the AIUncensoredImager class."""
-        self.url = "https://twitterclone-i0wr.onrender.com/api/image"
-        self.headers = {
-            "Content-Type": "application/json",
-            "Accept": "*/*",
-            "Origin": "https://www.aiuncensored.info",
-            "Referer": "https://www.aiuncensored.info/",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0",
-        }
-        self.session = requests.Session()
-        self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
-        self.timeout = timeout
-        self.prompt = "AI-generated image - webscout"
-        self.image_extension = "jpg"
-
-    def generate(self, prompt: str, amount: int = 1) -> List[str]:
-        """Generates image URLs from a prompt."""
-
-        assert bool(prompt), "Prompt cannot be null"
-        assert isinstance(amount, int) and amount > 0, "Amount must be a positive integer"
-        self.prompt = prompt
-
-        payload = {"prompt": prompt}
-        image_urls = []
-
-        try:
-            with self.session.post(self.url, json=payload, timeout=self.timeout) as response:
-                response.raise_for_status()  # Raise HTTPError for bad responses
-                data = response.json()
-                image_url = data.get("image_url")
-
-                if not image_url:
-                    raise exceptions.InvalidResponseError("No image URL in API response")
-
-                image_urls.append(image_url) # Only one image returned for now
-
-
-        except requests.exceptions.RequestException as e:
-            raise exceptions.APIConnectionError(f"Error during request: {e}")
-        except json.JSONDecodeError as e:
-            raise exceptions.InvalidResponseError(f"Invalid JSON response: {e}")
-        except Exception as e:
-            raise exceptions.FailedToGenerateResponseError(f"Unexpected error: {e}")
-
-        return image_urls
-
-    def save(
-        self,
-        response: List[str],
-        name: str = None,
-        dir: str = os.getcwd(),
-        filenames_prefix: str = "",
-    ) -> List[str]:
-        """Saves generated images."""
-
-        assert isinstance(response, list), f"Response should be a list, not {type(response)}"
-        name = self.prompt if name is None else name
-        os.makedirs(dir, exist_ok=True) #Create dir if needed
-
-        filenames = []
-        for i, img_url in enumerate(response):
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"{dir}/{name}_{i + 1}_{timestamp}.{self.image_extension}"
-            filenames.append(filenames_prefix + os.path.basename(filename))
-
-            try:
-                with self.session.get(img_url, stream=True, timeout=self.timeout) as img_response:
-                    img_response.raise_for_status()
-                    with open(filename, "wb") as f:
-                        for chunk in img_response.iter_content(chunk_size=8192):
-                            f.write(chunk)
-            except requests.exceptions.RequestException as e:
-                raise exceptions.FailedToSaveImageError(f"Error downloading/saving image: {e}")
-
-        return filenames
-
-
-if __name__ == "__main__":
-    imager = AIUncensoredImager()
-    prompt = "a photo of a cat sitting in a basket"
-    try:
-        image_urls = imager.generate(prompt, amount=1)
-        saved_filenames = imager.save(image_urls)
-        print(f"Saved filenames: {saved_filenames}")
-    except Exception as e:
-        print(f"An error occurred: {e}")

webscout/Provider/TTI/Nexra.py

@@ -1,120 +0,0 @@
-import requests
-import json
-import os
-import time
-from typing import List, Optional
-from requests.exceptions import RequestException
-
-from webscout.AIbase import ImageProvider
-
-class NexraImager(ImageProvider):
-    """Image provider for Nexra API"""
-
-    AVAILABLE_MODELS = {
-        "standard": ["emi", "stablediffusion-1.5", "stablediffusion-2.1", "sdxl-lora", "dalle", "dalle2", "dalle-mini", "flux", "midjourney"],
-        "prodia": [
-            "dreamshaperXL10_alpha2.safetensors [c8afe2ef]",
-            "dynavisionXL_0411.safetensors [c39cc051]",
-            "juggernautXL_v45.safetensors [e75f5471]",
-            "realismEngineSDXL_v10.safetensors [af771c3f]",
-            "sd_xl_base_1.0.safetensors [be9edd61]",
-            "animagineXLV3_v30.safetensors [75f2f05b]",
-            "sd_xl_base_1.0_inpainting_0.1.safetensors [5679a81a]",
-            "turbovisionXL_v431.safetensors [78890989]",
-            "devlishphotorealism_sdxl15.safetensors [77cba69f]",
-            "realvisxlV40.safetensors [f7fdcb51]"
-        ]
-    }
-
-    def __init__(self, timeout: int = 60, proxies: dict = {}):
-        self.url = "https://nexra.aryahcr.cc/api/image/complements"
-        self.headers = {"Content-Type": "application/json"}
-        self.session = requests.Session()
-        self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
-        self.timeout = timeout
-        self.prompt: str = "AI-generated image - webscout"
-        self.image_extension: str = "png"
-
-    def generate(
-        self, prompt: str, model: str = "flux", amount: int = 1,
-        max_retries: int = 3, retry_delay: int = 5,
-        additional_params: Optional[dict] = None
-    ) -> List[bytes]:
-        assert bool(prompt), "Prompt cannot be null"
-        assert isinstance(amount, int) and amount > 0, "Amount should be a positive integer"
-
-        self.prompt = prompt
-        response = []
-
-        payload = {
-            "prompt": prompt,
-            "model": "prodia" if model in self.AVAILABLE_MODELS["prodia"] else model,
-        }
-
-        if model in self.AVAILABLE_MODELS["prodia"]:
-            payload["data"] = {
-                "model": model,
-                "steps": 25,
-                "cfg_scale": 7,
-                "sampler": "DPM++ 2M Karras",
-                "negative_prompt": ""
-            }
-        if additional_params:
-            payload.update(additional_params)
-
-        for _ in range(max_retries):
-            try:
-                resp = self.session.post(self.url, json=payload, timeout=self.timeout)
-                resp.raise_for_status()
-
-                # Remove leading underscores and then parse JSON
-                response_data = json.loads(resp.text.lstrip("_"))
-
-                if response_data.get("status") and "images" in response_data:
-                    for image_url in response_data["images"]:
-                        img_resp = requests.get(image_url)
-                        img_resp.raise_for_status()
-                        response.append(img_resp.content)
-                    break
-                else:
-                    raise Exception("Failed to generate image: " + str(response_data))
-            except json.JSONDecodeError as json_err:
-                print(f"JSON Decode Error: {json_err}")
-                print(f"Raw response: {resp.text}")
-                if _ == max_retries - 1:
-                    raise
-            except RequestException as e:
-                print(f"Request Exception: {e}")
-                if _ == max_retries - 1:
-                    raise
-            print(f"Retrying in {retry_delay} seconds...")
-            time.sleep(retry_delay)
-
-        return response
-
-    def save(
-        self,
-        response: List[bytes],
-        name: str = None,
-        dir: str = os.getcwd(),
-        filenames_prefix: str = "",
-    ) -> List[str]:
-        assert isinstance(response, list), f"Response should be a list, not {type(response)}"
-        name = self.prompt if name is None else name
-
-        filenames = []
-        for i, image in enumerate(response):
-            filename = f"{filenames_prefix}{name}_{i}.{self.image_extension}"
-            filepath = os.path.join(dir, filename)
-
-            with open(filepath, "wb") as fh:
-                fh.write(image)
-            filenames.append(filename)
-
-        return filenames
-
-if __name__ == "__main__":
-    bot = NexraImager()
-    resp_standard = bot.generate("AI-generated image - webscout", "midjourney", 1)
-    print(bot.save(resp_standard))

webscout/Provider/TTI/PollinationsAI.py

@@ -1,138 +0,0 @@
-import requests
-import os
-import time
-from typing import List
-from string import punctuation
-from random import choice
-from requests.exceptions import RequestException
-
-from webscout.AIbase import ImageProvider
-
-class PollinationsAI(ImageProvider):
-    """Image provider for pollinations.ai"""
-
-    def __init__(self, timeout: int = 60, proxies: dict = {}):
-        """Initializes the PollinationsAI class.
-
-        Args:
-            timeout (int, optional): HTTP request timeout in seconds. Defaults to 60.
-            proxies (dict, optional): HTTP request proxies (socks). Defaults to {}.
-        """
-        self.image_gen_endpoint = "https://image.pollinations.ai/prompt/{prompt}?width={width}&height={height}&model={model}"
-        self.headers = {
-            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-            "Accept-Language": "en-US,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate",
-            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0",
-        }
-        self.session = requests.Session()
-        self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
-        self.timeout = timeout
-        self.prompt: str = "AI-generated image - webscout"
-        self.image_extension: str = "jpeg"
-
-    def generate(
-        self, prompt: str, amount: int = 1, additives: bool = True,
-        width: int = 768, height: int = 768, model: str = "flux",
-        max_retries: int = 3, retry_delay: int = 5
-    ) -> List[bytes]:
-        """Generate image from prompt
-
-        Args:
-            prompt (str): Image description.
-            amount (int): Total images to be generated. Defaults to 1.
-            additives (bool, optional): Try to make each prompt unique. Defaults to True.
-            width (int, optional): Width of the generated image. Defaults to 768.
-            height (int, optional): Height of the generated image. Defaults to 768.
-            model (str, optional): The model to use for image generation. Defaults to "flux".
-            max_retries (int, optional): Maximum number of retry attempts. Defaults to 3.
-            retry_delay (int, optional): Delay between retries in seconds. Defaults to 5.
-
-        Returns:
-            List[bytes]: List of generated images as bytes.
-        """
-        assert bool(prompt), "Prompt cannot be null"
-        assert isinstance(amount, int), f"Amount should be an integer only not {type(amount)}"
-        assert amount > 0, "Amount should be greater than 0"
-
-        ads = lambda: (
-            ""
-            if not additives
-            else choice(punctuation)
-            + choice(punctuation)
-            + choice(punctuation)
-            + choice(punctuation)
-            + choice(punctuation)
-        )
-
-        self.prompt = prompt
-        response = []
-        for _ in range(amount):
-            url = self.image_gen_endpoint.format(
-                prompt=prompt + ads(), width=width, height=height, model=model
-            )
-            
-            for attempt in range(max_retries):
-                try:
-                    resp = self.session.get(url, timeout=self.timeout)
-                    resp.raise_for_status()
-                    response.append(resp.content)
-                    break
-                except RequestException as e:
-                    if attempt == max_retries - 1:
-                        print(f"Failed to generate image after {max_retries} attempts: {e}")
-                        raise
-                    else:
-                        print(f"Attempt {attempt + 1} failed. Retrying in {retry_delay} seconds...")
-                        time.sleep(retry_delay)
-
-        return response
-
-    def save(
-        self,
-        response: List[bytes],
-        name: str = None,
-        dir: str = os.getcwd(),
-        filenames_prefix: str = "",
-    ) -> List[str]:
-        """Save generated images
-
-        Args:
-            response (List[bytes]): List of generated images as bytes.
-            name (str): Filename for the images. Defaults to the last prompt.
-            dir (str, optional): Directory for saving images. Defaults to os.getcwd().
-            filenames_prefix (str, optional): String to be prefixed at each filename to be returned.
-
-        Returns:
-            List[str]: List of saved filenames.
-        """
-        assert isinstance(response, list), f"Response should be of {list} not {type(response)}"
-        name = self.prompt if name is None else name
-
-        filenames = []
-        count = 0
-        for image in response:
-            def complete_path():
-                count_value = "" if count == 0 else f"_{count}"
-                return os.path.join(dir, name + count_value + "." + self.image_extension)
-
-            while os.path.isfile(complete_path()):
-                count += 1
-
-            absolute_path_to_file = complete_path()
-            filenames.append(filenames_prefix + os.path.split(absolute_path_to_file)[1])
-
-            with open(absolute_path_to_file, "wb") as fh:
-                fh.write(image)
-
-        return filenames
-
-
-if __name__ == "__main__":
-    bot = PollinationsAI()
-    try:
-        resp = bot.generate("AI-generated image - webscout", 1)
-        print(bot.save(resp))
-    except Exception as e:
-        print(f"An error occurred: {e}")

webscout/Provider/TTI/WebSimAI.py

@@ -1,142 +0,0 @@
-import requests
-import os
-from typing import List
-
-from webscout.AIbase import ImageProvider
-
-class WebSimAI(ImageProvider):
-    """
-    Image provider for WebSim.ai.
-    """
-
-    def __init__(self, timeout: int = 60, proxies: dict = {}):
-        """Initializes the WebSimAI class.
-
-        Args:
-            timeout (int, optional): HTTP request timeout in seconds. Defaults to 60.
-            proxies (dict, optional): HTTP request proxies (socks). Defaults to {}.
-        """
-        self.url = "https://websim.ai/api/image_gen"
-        self.headers = {
-            "Accept": "*/*",
-            "Accept-Encoding": "gzip, deflate, br, zstd",
-            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "Content-Type": "application/json",
-            "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"
-            ),
-            "Origin": "https://websim.ai",
-            "Referer": "https://websim.ai/p/a5yvwmtj8qz6ayx4tlg1"
-        }
-        self.session = requests.Session()
-        self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
-        self.timeout = timeout
-        self.prompt: str = "AI-generated image - Webscout"
-        self.image_extension: str = "png"  
-
-    def generate(
-        self, 
-        prompt: str, 
-        amount: int = 1, 
-        width: int = 1024, 
-        height: int = 756
-    ) -> List[bytes]:
-        """Generate image from prompt
-
-        Args:
-            prompt (str): Image description.
-            amount (int, optional): Total images to be generated. Defaults to 1.
-            width (int, optional): Width of the generated image. Defaults to 1024.
-            height (int, optional): Height of the generated image. Defaults to 756.
-
-        Returns:
-            List[bytes]: List of generated images as bytes.
-        """
-        assert bool(prompt), "Prompt cannot be null"
-        assert isinstance(amount, int), f"Amount should be an integer only, not {type(amount)}"
-        assert amount > 0, "Amount should be greater than 0"
-
-        self.prompt = prompt
-        response = []
-
-        for _ in range(amount):
-            payload = {
-                "prompt": prompt,
-                "width": width,
-                "height": height,
-                "site_id": "KcWvHOHNBP2PmWUYZ",
-            }
-
-            try:
-                resp = self.session.post(self.url, headers=self.headers, json=payload, timeout=self.timeout)
-                resp.raise_for_status()  # Raises HTTPError for bad responses
-
-                response_data = resp.json()
-                image_url = response_data.get("url")
-                if not image_url:
-                    print("No image URL found in the response.")
-                    continue
-
-                image_response = requests.get(image_url)
-                image_response.raise_for_status()
-                response.append(image_response.content)
-
-            except requests.exceptions.HTTPError as http_err:
-                print(f"HTTP error occurred: {http_err} - {response.text}")
-                return []  # Return an empty list on error
-            except requests.exceptions.RequestException as req_err:
-                print(f"Request error occurred: {req_err}")
-                return []  # Return an empty list on error
-
-        return response
-
-    def save(
-        self,
-        response: List[bytes],
-        name: str = None,
-        dir: str = os.getcwd(),
-        filenames_prefix: str = "",
-    ) -> List[str]:
-        """Save generated images
-
-        Args:
-            response (List[bytes]): List of generated images as bytes.
-            name (str): Filename for the images. Defaults to the last prompt.
-            dir (str, optional): Directory for saving images. Defaults to os.getcwd().
-            filenames_prefix (str, optional): String to be prefixed at each filename to be returned.
-
-        Returns:
-            List[str]: List of saved filenames.
-        """
-        assert isinstance(response, list), f"Response should be of {list} not {type(response)}"
-        name = self.prompt if name is None else name
-
-        filenames = []
-        count = 0
-        for image in response:
-            def complete_path():
-                count_value = "" if count == 0 else f"_{count}"
-                return os.path.join(dir, name + count_value + "." + self.image_extension)
-
-            while os.path.isfile(complete_path()):
-                count += 1
-
-            absolute_path_to_file = complete_path()
-            filenames.append(filenames_prefix + os.path.split(absolute_path_to_file)[1])
-
-            with open(absolute_path_to_file, "wb") as fh:
-                fh.write(image)
-
-        return filenames
-
-
-if __name__ == "__main__":
-    bot = WebSimAI()
-    try:
-        resp = bot.generate("A shiny red sports car speeding down a scenic mountain road", 1)
-        print(bot.save(resp))
-    except Exception as e:
-        print(f"An error occurred: {e}")