autowebx 1.0.0__tar.gz

autowebx-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: autowebx
+Version: 1.0.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: beautifulsoup4>=4.13.4
+Requires-Dist: names>=0.3.0
+Requires-Dist: phonenumbers>=9.0.6
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: art>=6.5
+Requires-Dist: multipledispatch>=1.0.0
+Requires-Dist: ntplib>=0.4.0
+Dynamic: requires-dist

autowebx-1.0.0/autowebx/__init__.py

@@ -0,0 +1,217 @@
+import inspect
+import json
+import threading
+from calendar import monthrange
+from datetime import datetime
+from sys import exc_info, argv
+from time import sleep, time
+from urllib.parse import unquote, parse_qs, urlparse
+from uuid import getnode
+
+from art import text2art
+from colorama import Fore
+from ntplib import NTPClient
+from phonenumbers import region_code_for_number, parse
+
+from autoweb.files import add
+
+__lock = threading.Lock()
+
+
+class AccountError(Exception):
+    """Raised when an account fails to create"""
+
+
+def int_input(prompt: str, default: int = 1) -> int:
+    try:
+        return int(input(prompt))
+    except ValueError:
+        return default
+
+
+def intro(name: str):
+    user_id = getnode()
+    sync_print('=' * 85)
+    sync_print(f'{Fore.LIGHTYELLOW_EX}{text2art("Hazem3010", "banner3")}')
+    indent = " " * int((85 - len(f'{name}    ::    Your ID: {user_id}')) / 2)
+    sync_print(f'{indent}{Fore.GREEN}{name}{Fore.LIGHTMAGENTA_EX}    ::    {Fore.CYAN}Your ID: {user_id}{Fore.RESET}')
+    sync_print('=' * 85)
+    return str(user_id)
+
+
+class PhoneNumber:
+    def __init__(self, phone_number):
+        self.number = phone_number
+        parsed_number = parse(f'+{phone_number}')
+        self.prefix = parsed_number.country_code
+        self.country = region_code_for_number(parsed_number)
+
+
+def sync_print(*content, end: str = '\n'):
+    __lock.acquire()
+    print(*content, end=end, flush=True)
+    add(f"{' '.join(map(str, content))}{end}", 'output.txt')
+    __lock.release()
+
+
+class URL:
+    def __init__(self, url: str):
+        self.__parameters__ = parse_qs(urlparse(url).query)
+
+    def get(self, parameter: str) -> str:
+        return self.__parameters__.get(parameter)[0]
+
+
+def __get_function__() -> None:
+    http = argv[1]
+    http_content = open(http, 'r').read()
+    lines = http_content.split('\n')
+    method, endpoint, _ = lines[0].split(' ')
+    endpoint = unquote(endpoint).replace("\"", "\\\"")
+
+    # Extract headers properly
+    headers = {}
+    host = ""
+    for line in lines[1:]:
+        if line == '':
+            break
+        line_data = line.split(':', 1)
+        if len(line_data) == 2:
+            key, value = line_data[0].strip(), unquote(line_data[1].strip())
+            headers[key] = value
+            if key.lower() == "host":
+                host = value
+
+    if not host:
+        raise ValueError("Host header is missing in the request")
+
+    result = f'def function(self):    # {http}\n    url = "https://{host}{endpoint}"\n\n'
+
+    result += "    headers = {\n"
+    for key, value in headers.items():
+        result += f"        '{key}': '{value}',\n"
+    result = result[:-2] + "\n    }\n\n"
+
+    content = http_content.split('\n\n')
+    with_payload = False
+    json_payload = False
+    if len(content) > 1 and content[1] != '':
+        with_payload = True
+        result += '    payload = '
+        variables_content = content[1].strip()
+        if variables_content.startswith('{'):
+            payload = json.loads(variables_content)
+            json_payload = True
+        else:
+            variables = content[1].strip().split('&')
+            payload = {}
+            for item in variables:
+                try:
+                    pair = item.split('=')
+                    payload[pair[0]] = unquote(pair[1])
+                except IndexError:
+                    pass
+
+        payload = json.dumps(payload, indent=4).replace('\n', '\n    ').replace(': true', ': True')
+        payload = payload.replace(': false', ': False')
+        result += unquote(payload)
+        result = result + '\n\n'
+
+    args = f'(url, headers=headers{", json=payload)" if json_payload else ", data=payload)" if with_payload else ")"}'
+    result += f'    response = self.session.{method.lower()}{args}\n'
+    result = result.replace('\t', '    ')
+
+    open('function.py', 'w', encoding='UTF-8').write(result)
+
+
+def ranges(numbers: list[str]) -> list[str]:
+    return list({number[:-3] for number in numbers})
+
+
+def days_in_month(year: int, month: int) -> int:
+    return monthrange(year, month)[1]
+
+
+def handle_threads(threads: int, total: int, target) -> None:
+    for i in range(1, total + 1):
+        target(count=i).start()
+        while True:
+            active = 0
+            for thread in threading.enumerate():
+                if thread.name.startswith('Task_'):
+                    active += 1
+            if active < threads:
+                break
+            sleep(1)
+
+    done = False
+    while not done:
+        done = True
+        for thread in threading.enumerate():
+            if thread.name.startswith('Task_'):
+                done = False
+                break
+
+
+
+def var_name(var):
+    for name, value in inspect.stack()[1].frame.f_locals.items():
+        if value is var:
+            return name
+    return None
+
+
+useragents = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 "
+    "Safari/537.36 Edg/123.0.2420.81",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 "
+    "Safari/537.36 OPR/109.0.0.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 "
+    "Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14.4; rv:124.0) Gecko/20100101 Firefox/124.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 "
+    "Safari/605.1.15",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 "
+    "Safari/537.36 OPR/109.0.0.0",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (X11; Linux i686; rv:124.0) Gecko/20100101 Firefox/124.0"
+]
+
+__locales_str = (
+    "af_ZAam_ETar_AEar_BHar_DZar_EGar_IQar_JOar_KWar_LBar_LYar_MAar_OMar_QAar_SAar_SDar_SYar_TNar_YEaz_AZbe_BYbg_BGbn_B"
+    "Dbn_INbs_BAca_EScs_CZcy_GBda_DKde_ATde_BEde_CHde_DEde_LIde_LUdv_MVel_CYel_GRen_AUen_BWen_CAen_GBen_HKen_IEen_INen_"
+    "JMen_MHen_MTen_NAen_NZen_PHen_PKen_SGen_TTen_USen_ZAen_ZWes_ARes_BOes_CLes_COes_CRes_DOes_ECes_ESes_GTes_HNes_MXes"
+    "_NIes_PAes_PEes_PRes_PYes_SVes_USes_UYes_VEet_EEeu_ESfa_IRfi_FIfo_FOfr_BEfr_BFfr_BIfr_BJfr_BLfr_CAfr_CDfr_CFfr_CGf"
+    "r_CHfr_CIfr_CMfr_DJfr_FRfr_GAfr_GFfr_GNfr_GPfr_GQfr_HTfr_KMfr_LUfr_MAfr_MCfr_MFfr_MGfr_MLfr_MQfr_NEfr_PFfr_PMfr_RE"
+    "fr_RWfr_SCfr_SNfr_SYfr_TDfr_TGfr_TNfr_VUfr_WFfr_YTga_IEgl_ESgu_INha_NGhe_ILhi_INhr_BAhr_HRhu_HUhy_AMid_IDig_NGis_I"
+    "Sit_CHit_ITja_JPka_GEkk_KZkm_KHkn_INko_KRky_KGlo_LAlt_LTlv_LVmg_MGmk_MKml_INmn_MNmr_INms_BNms_MYmt_MTnb_NOne_NPnl_"
+    "AWnl_BEnl_NLnn_NOom_ETor_INpa_INpl_PLps_AFpt_AOpt_BRpt_CHpt_CVpt_FRpt_GQpt_GWpt_LUpt_MOpt_MZpt_PTpt_STpt_TLro_MDro"
+    "_ROru_BYru_KGru_KZru_MDru_RUru_UArw_RWsd_INsi_LKsk_SKsl_SIso_DJso_ETso_KEso_SOsq_ALsr_BAsr_MEsr_RSsv_AXsv_FIsv_SEs"
+    "w_CDsw_KEsw_TZsw_UGta_INta_LKte_INth_THti_ERti_ETtl_PHtn_BWtn_ZAtr_CYtr_TRug_CNuk_UAur_INur_PKuz_AFuz_UZvi_VNyo_NG"
+    "zh_CNzh_HKzh_MOzh_SGzh_TWzu_ZA"
+)
+
+
+def locales():
+    return [__locales_str[i:i + 5] for i in range(0, len(__locales_str), 5)]
+
+
+def exception_line():
+    return exc_info()[-1].tb_lineno
+
+
+def internet_time():
+    return datetime.fromtimestamp(NTPClient().request('pool.ntp.org').tx_time)
+
+
+class Timer:
+    def __init__(self, timeout, message):
+        self.timeout = timeout
+        self.start = time()
+        self.message = message
+
+    def __call__(self):
+        if time() - self.start > self.timeout:
+            raise TimeoutError(self.message)

autowebx-1.0.0/autowebx/account.py

@@ -0,0 +1,82 @@
+import random
+from string import digits, ascii_lowercase, ascii_uppercase
+
+from names import get_first_name
+
+
+class Account:
+    def __init__(self, **kwargs):
+        self.first_name = kwargs.get("first_name", get_first_name())
+        self.last_name = kwargs.get("last_name", get_first_name())
+        self.full_name = self.first_name + " " + self.last_name
+        domain = kwargs.get("domain", 'gmail.com')
+        if 'username' in kwargs.keys():
+            self.username = kwargs["username"]
+        elif 'email_length' in kwargs.keys():
+            self.username = generate_username(self.first_name, kwargs["email_length"] - len(domain))
+        elif 'username_length' in kwargs.keys():
+            self.username = generate_username(self.first_name, kwargs["username_length"])
+        else:
+            self.username = generate_username(self.first_name)
+        self.email = kwargs.get("email", f'{self.username}@{domain}')
+        password_length = kwargs.get("password_length", None)
+        additional_characters = kwargs.get('additional_characters', '')
+        self.password = kwargs.get("password", generate_password(password_length, additional_characters))
+        self.phone_number = generate_us_number()
+        self.address_line1 = generate_address_line_1()
+        self.city = get_random_city()
+
+
+def generate_username(name: str = get_first_name(), length: int = random.randint(10, 15)):
+    return f'{name}{"".join(random.choice(digits) for _ in range(length - len(name)))}'.lower()
+
+
+def generate_password(length: int | None = None, additional_characters: str = ''):
+    if length is None:
+        length = random.randint(10, 20)
+    while True:
+        try:
+            character_set = ascii_lowercase + ascii_uppercase + digits + additional_characters
+            password = ''.join(random.choice(character_set) for _ in range(length))
+            contains_lower = any(character in ascii_lowercase for character in password)
+            contains_upper = any(character in ascii_uppercase for character in password)
+            contains_digit = any(character.isdigit() for character in password)
+            contains_others = any(character in additional_characters for character in password)
+            contains_both_cases = contains_lower and contains_upper
+            if contains_digit and (contains_others if additional_characters else True) and contains_both_cases:
+                return password
+            else:
+                return generate_password(length, additional_characters)
+        except RecursionError:
+            pass
+
+
+def generate_us_number():
+    area_code = str(random.randint(200, 999))         # Avoids starting with 0 or 1
+    exchange_code = str(random.randint(200, 999))     # Same here
+    subscriber_number = str(random.randint(0, 9999)).zfill(4)
+
+    return f"{area_code}{exchange_code}{subscriber_number}"
+
+
+def generate_address_line_1():
+    street_numbers = range(100, 9999)
+    street_names = [
+        "Main", "Oak", "Pine", "Maple", "Cedar", "Elm", "Washington", "Lake", "Hill", "Sunset"
+    ]
+    street_types = ["St", "Ave", "Blvd", "Rd", "Ln", "Dr", "Ct", "Pl", "Way", "Terrace"]
+
+    number = str(random.choice(street_numbers))
+    name = random.choice(street_names)
+    st_type = random.choice(street_types)
+
+    return f"{number} {name} {st_type}"
+
+
+def get_random_city():
+    cities = [
+        "New York", "Tokyo", "London", "Paris", "Berlin",
+        "Cairo", "Dubai", "Istanbul", "Sydney", "Toronto",
+        "Rio de Janeiro", "Moscow", "Seoul", "Bangkok", "Mumbai"
+    ]
+    return random.choice(cities)

autowebx-1.0.0/autowebx/auto_save_dict.py

@@ -0,0 +1,68 @@
+import json
+from json import JSONDecodeError
+from typing import Union, Mapping, Any, Iterable, Tuple
+
+from autoweb import var_name
+
+
+class AutoSaveDict(dict):
+    def __init__(self, file_path: str = 'dict.json'):
+        self.__file_path = file_path
+        try:
+            super().__init__(json.load(open(self.__file_path, 'r', encoding='utf-8')))
+        except (FileNotFoundError, JSONDecodeError):
+            super().__init__()
+
+        self.__save()
+
+    def __save(self, ):
+        json.dump(self, open(self.__file_path, 'w', encoding='utf-8', errors='ignore'), indent=2, ensure_ascii=False)
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        self.__save()
+
+    def __delitem__(self, key):
+        super().__delitem__(key)
+        self.__save()
+
+    def update(
+            self,
+            __m: Union[Mapping[Any, Any], Iterable[Tuple[Any, Any]]] = (),
+            **kwargs: Any
+    ) -> None:
+        """
+        يغطّي حالتين أساسيتين:
+        1. update(dict_or_mapping)
+        2. update([(k1, v1), (k2, v2), ...], key=value, ...)
+        """
+        # أولًا: ننفّذ وظيفة الـ dict الأصلية (ترحيل القيم)
+        super().update(__m, **kwargs)
+        # بعد ذلك: نحفظ القاموس في المِلَفّ
+        self.__save()
+
+    def clear(self):
+        super().clear()
+        self.__save()
+
+    def __call__(self, key, from_list: list = None, loop: bool = False):
+        answer = self.setdefault(key, 0)
+        if isinstance(answer, int):
+            if from_list is not None:
+                if answer < len(from_list):
+                    self[key] = answer + 1
+                    return from_list[answer]
+                else:
+                    if loop:
+                        self[key] = 0
+                        if len(from_list) > 0:
+                            return self(key, from_list, loop)
+                        else:
+                            raise IndexError(f"The list {var_name(from_list)} is empty")
+                    else:
+                        raise IndexError('IndexError: list index out of range')
+            else:
+                self[key] = answer + 1
+                return answer
+        else:
+            return answer

autowebx-1.0.0/autowebx/auto_save_queue.py

@@ -0,0 +1,65 @@
+import queue
+import threading
+import time
+import json
+from abc import ABC
+from collections import deque
+from collections.abc import Iterable
+from threading import Event
+
+
+class AutoSaveQueue(queue.Queue, Iterable, ABC):
+    def __init__(self, file_path, auto_save_interval=5, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.file_path = file_path
+        self.auto_save_interval = auto_save_interval
+        self._stop_event = Event()
+        self._start_auto_save()
+
+    def _start_auto_save(self):
+        """Start the auto-save thread that saves the queue to the file at regular intervals."""
+        self.auto_save_thread = threading.Thread(target=self._auto_save)
+        self.auto_save_thread.daemon = True
+        self.auto_save_thread.start()
+
+    def _auto_save(self):
+        """Automatically save the queue to a file at regular intervals."""
+        while not self._stop_event.is_set():
+            self.save()
+            time.sleep(self.auto_save_interval)
+
+    def save(self):
+        """Save the current state of the queue to a file."""
+        with self.mutex:
+            open(self.file_path, 'w').write('\n'.join(str(item) for item in self))
+
+    def stop(self):
+        """Stop the auto-save thread."""
+        self._stop_event.set()
+        self.auto_save_thread.join()
+
+    def put(self, item, *args, **kwargs):
+        """Override the put method to save after adding an item."""
+        super().put(item, *args, **kwargs)
+        self.save()
+
+    def get(self, *args, **kwargs):
+        """Override the get method to save after removing an item."""
+        item = super().get(*args, **kwargs)
+        self.save()
+        return item
+
+    def load(self):
+        """Load the queue from a file."""
+        try:
+            with open(self.file_path, 'r') as f:
+                data = json.load(f)
+                with self.mutex:
+                    self.queue = deque(data)
+        except (FileNotFoundError, json.JSONDecodeError):
+            pass  # Ignore errors when the file doesn't exist or is empty
+
+# Usage
+auto_queue = AutoSaveQueue("queue_data.json", auto_save_interval=10)
+auto_queue.put("task 1")
+auto_queue.put("task 2")

autowebx-1.0.0/autowebx/auto_save_set.py

@@ -0,0 +1,53 @@
+from autoweb.files import load
+
+
+class AutoSaveSet(set):
+    def __init__(self, filename):
+        super().__init__(load(filename))
+        self.filename = filename
+        self._save_to_file()
+
+    def _save_to_file(self):
+        open(self.filename, 'w').write('\n'.join(self))
+
+    def add(self, element):
+        super().add(element)
+        self._save_to_file()
+
+    def remove(self, element):
+        super().remove(element)
+        self._save_to_file()
+
+    def update(self, *args):
+        super().update(*args)
+        self._save_to_file()
+
+    def discard(self, element):
+        super().discard(element)
+        self._save_to_file()
+
+    def clear(self):
+        super().clear()
+        self._save_to_file()
+
+    def pop(self):
+        element = super().pop()
+        self._save_to_file()
+        return element
+
+    def difference_update(self, *args):
+        super().difference_update(*args)
+        self._save_to_file()
+
+    def intersection_update(self, *args):
+        super().intersection_update(*args)
+        self._save_to_file()
+
+    def symmetric_difference_update(self, *args):
+        super().symmetric_difference_update(*args)
+        self._save_to_file()
+
+    def __iadd__(self, elements):
+        super().update(elements)
+        self._save_to_file()
+        return self

autowebx-1.0.0/autowebx/capsolver.py

@@ -0,0 +1,41 @@
+from random import randint
+from time import time, sleep
+
+from requests import post
+
+
+class RecaptchaV2:
+    def __init__(self, apikey: str, website_url: str, website_key: str, is_invisible: bool = False):
+        self.client_key = apikey
+
+        data = {
+            "clientKey": apikey,
+            "task": {
+                "type": "RecaptchaV2TaskProxyless",
+                "websiteURL": website_url,
+                "websiteKey": website_key,
+                "isInvisible": is_invisible
+            }
+        }
+
+        response = post('https://api.capsolver.com/createTask', json=data).json()
+        self.task_id = response['taskId']
+        self.submit_time = time()
+
+    def solution(self, timeout=randint(15, 20)):
+        while time() < self.submit_time + timeout:
+            pass
+
+        data = {
+            "clientKey": self.client_key,
+            "taskId": self.task_id
+        }
+
+        while True:
+            response = post('https://api.capsolver.com/getTaskResult', json=data).json()
+            if response['status'] == 'processing':
+                sleep(5)
+            elif error_id := response['errorId'] != 0:
+                raise Exception(f'{error_id}:{response["errorCode"]}:{response["errorDescription"]}')
+            else:
+                return response['solution']['gRecaptchaResponse']

autowebx-1.0.0/autowebx/communications.py

@@ -0,0 +1,20 @@
+from multiprocessing.connection import Listener
+from multiprocessing.connection import Client
+from threading import Lock
+
+__lock = Lock()
+
+
+def send(msg):
+    with Listener(('localhost', 3011)) as listener:
+        with listener.accept() as conn:
+            conn.send(msg)
+
+
+def receive():
+    with __lock:
+        try:
+            with Client(('localhost', 3011)) as conn:
+                return conn.recv()
+        except ConnectionRefusedError:
+            raise ConnectionRefusedError("Run the sender first")

autowebx-1.0.0/autowebx/email_fake.py

@@ -0,0 +1,78 @@
+import re
+from time import time
+
+from bs4 import BeautifulSoup, Tag, ResultSet
+from bs4.element import PageElement, NavigableString
+from requests import get, post, ConnectTimeout, ConnectionError
+
+
+def get_suggestions():
+    html = get("https://email-fake.com/").text
+    soup = BeautifulSoup(html, "html.parser")
+    return [child.text for child in soup.find('div', class_="tt-suggestions").children]
+
+
+def get_message(
+        email: str | Tag, timeout: int | float = 30
+) -> None | PageElement | BeautifulSoup | NavigableString | ResultSet[Tag]:
+    if isinstance(email, str):
+        url = "https://email-fake.com/"
+        username, domain = email.split("@")
+        surl = f'{domain}/{username}'
+        start = time()
+        exception = None
+        while time() - start < timeout:
+            try:
+                response = get(url, cookies={'surl': surl}).text
+                soup = BeautifulSoup(response, 'html.parser')
+                tag = soup.find('div', class_='mess_bodiyy')
+                if tag:
+                    delll = re.search(r'delll: "([^"]+)"', response).group(1)
+                    cookies = {'surl': surl, 'embx': f'["{email}"]'}
+                    post('https://email-fake.com/del_mail.php', {'delll': delll}, cookies=cookies)
+                    return tag
+                else:
+                    exception = TimeoutError("No message received")
+                tags = soup.select('#email-table a')
+                if len(tags) > 0:
+                    return tags
+            except (ConnectionError, ConnectTimeout):
+                exception = ConnectionError("There is no internet connection")
+        raise exception
+    elif isinstance(email, Tag):
+        start = time()
+        exception = None
+        while time() - start < timeout:
+            try:
+                print(url := f'https://www.email-fake.com{email.get("href")}')
+                response = get(url).text
+                soup = BeautifulSoup(response, 'html.parser')
+                tag = soup.find('div', class_='mess_bodiyy')
+                if tag:
+                    return tag
+            except ConnectionError:
+                exception = ConnectionError("There is no internet connection")
+        raise exception
+    return None
+
+
+def delete_all_messages(email: str):
+    username, domain = email.split("@")
+    surl = f'{domain}/{username}'
+    response = get("https://email-fake.com/", cookies={'surl': surl}).text
+
+    if match := re.search(r'delll: "([^"]+)"', response):
+        delll = match.group(1)
+        cookies = {'surl': surl, 'embx': f'["{email}"]'}
+        post('https://email-fake.com/del_mail.php', {'delll': delll}, cookies=cookies)
+
+    if match := re.search(r'dellall: "([^"]+)"', response):
+        dellall = match.group(1)
+        url = "https://email-fake.com/del_mail.php"
+        headers = {
+            'Cookie': f'surl={surl}; embx=["{email}"]'
+        }
+        payload = {
+            "dellall": dellall
+        }
+        post(url, headers=headers, data=payload)