autowebx 1.0.0__py3-none-any.whl

autowebx/files.py

@@ -0,0 +1,82 @@
+from threading import Lock, Thread, Condition
+
+__lock = Lock()
+
+
+def add(text: str, to: str) -> None:
+    __lock.acquire()
+    open(to, 'a').write(text)
+    __lock.release()
+
+
+def load(*paths: str) -> list[str] | list[list[str]]:
+    lists = []
+    for file_name in paths:
+        try:
+            lists.append(open(file_name, 'r').read().strip().split('\n'))
+        except FileNotFoundError:
+            open(file_name, 'w').write('')
+            lists.append([])
+    return lists if len(lists) > 1 else lists[0]
+
+
+def replace(old: str, new: str, path: str) -> None:
+    with __lock:
+        old_content = open(path, 'r').read()
+    new_content = old_content.replace(old, new)
+    with __lock:
+        open(path, 'w').write(new_content)
+
+
+class File:
+    def __init__(self, path: str) -> None:
+        self.__path = path
+        with open(self.__path, 'r') as file:
+            self.__buffer = file.read()
+        self.__changed = False
+        self.__closed = False
+        self.__lock = Lock()
+        self.__condition = Condition(self.__lock)
+        self.lines = self.__buffer.split('\n')
+        self.__thread = Thread(target=self.__update, daemon=True)
+        self.__thread.start()
+
+    def __update(self):
+        while True:
+            with self.__condition:
+                while not self.__changed and not self.__closed:
+                    self.__condition.wait()
+                if self.__closed:
+                    break
+                if not self.__buffer.strip():  # Avoid writing empty content
+                    continue
+                with open(self.__path, 'w') as file:
+                    file.write(self.__buffer)
+                self.__changed = False
+
+    def replace(self, old: str, new: str) -> None:
+        with self.__condition:
+            self.__buffer = self.__buffer.replace(old, new)
+            self.lines = self.__buffer.split('\n')
+            self.__changed = True
+            self.__condition.notify()
+
+    def add(self, text: str) -> None:
+        with self.__condition:
+            self.__buffer += text
+            self.lines = self.__buffer.split('\n')
+            self.__changed = True
+            self.__condition.notify()
+
+    def close(self) -> None:
+        with self.__condition:
+            if not self.__closed:
+                with open(self.__path, 'w') as file:
+                    file.write(self.__buffer)
+                self.__closed = True
+                self.__condition.notify()
+        self.__thread.join()
+
+    def __del__(self):
+        if not self.__closed:
+            self.close()

autowebx/five_sim.py

@@ -0,0 +1,56 @@
+import time
+import requests
+
+DOMAIN = "5sim.net"
+
+
+class Phone:
+    def __init__(self, number_id, phone):
+        self.id = number_id
+        self.number = phone
+
+
+class FiveSim:
+    def __init__(self, token):
+        self.headers = {
+            'Authorization': 'Bearer ' + token,
+            'Accept': 'application/json',
+        }
+
+    def balance(self):
+        response = requests.get(f'https://{DOMAIN}/v1/user/profile', headers=self.headers)
+        return response.json()['balance']
+
+    def buy_activation_number(self, country: str, operator: str, product: str):
+        url = f'https://{DOMAIN}/v1/user/buy/activation/{country}/{operator}/{product}'
+        response = requests.get(url, headers=self.headers).json()
+        return Phone(response['id'], response['phone'][1:])
+
+    def get_codes(self, phone: Phone, timeout: float = 30):
+        start = time.time()
+        while True:
+            try:
+                response = requests.get(f'https://{DOMAIN}/v1/user/check/{phone.id}', headers=self.headers).json()
+                return [sms['code'] for sms in response['sms']]
+            except (ValueError, IndexError):
+                pass
+
+            if time.time() - start > timeout:
+                raise TimeoutError
+
+
+def min_cost_providers(country: str, product: str):
+    response = requests.get(f'https://{DOMAIN}/v1/guest/prices?country={country}&product={product}').json()
+    operators0 = []
+    for operator in response[country][product]:
+        if response[country][product][operator]['count'] != 0:
+            operators0.append(operator)
+    min_cost = response[country][product][operators0[0]]['cost']
+    for operator in operators0:
+        if response[country][product][operator]['cost'] < min_cost:
+            min_cost = response[country][product][operator]['cost']
+    operators1 = []
+    for operator in operators0:
+        if response[country][product][operator]['cost'] == min_cost:
+            operators1.append(operator)
+    return operators1

autowebx/inboxes.py

@@ -0,0 +1,90 @@
+from time import time, sleep
+
+from requests import Session
+
+
+class Message:
+    def __init__(self, uid, sender, subject, received, receiver):
+        self.id = uid
+        self.sender = sender
+        self.subject = subject
+        self.received = received
+        self.receiver = receiver
+
+
+class Inboxes:
+    def __init__(self, email,  timeout: int = 30):
+        url = "https://inboxes.com/api/v2/domain"
+
+        headers = {
+            'Host': 'inboxes.com',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:130.0) Gecko/20100101 Firefox/130.0',
+            'Accept': '*/*',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Referer': 'https://inboxes.com/',
+            'DNT': '1',
+            'Sec-GPC': '1',
+            'Connection': 'close',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Priority': 'u=0'
+        }
+        self.session = Session()
+        self.session.get(url, headers=headers)
+        self.timeout = timeout
+        self.messages = list()
+        self.email = email
+
+    def inbox(self, timeout=None) -> list[Message]:  # 102
+        url = f"https://inboxes.com/api/v2/inbox/{self.email}"
+
+        headers = {
+            'Host': 'inboxes.com',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:130.0) Gecko/20100101 Firefox/130.0',
+            'Accept': '*/*',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Referer': 'https://inboxes.com/',
+            'authorization': 'Bearer null',
+            'DNT': '1',
+            'Sec-GPC': '1',
+            'Connection': 'close',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Priority': 'u=0'
+        }
+        start = time()
+        while time() - start < (timeout or self.timeout):
+            response = self.session.get(url, headers=headers).json()
+            if result := [Message(msg['uid'], msg['f'], msg['s'], msg['r'], self.email) for msg in
+                          response.get('msgs', [])]:
+                for msg in result:
+                    self.messages.append(msg)
+                    return self.messages
+            sleep(0.5)
+        return []
+
+    def html(self, msg: Message):  # 2746
+        url = f"https://inboxes.com/api/v2/message/{msg.id}"
+
+        headers = {
+            'Host': 'inboxes.com',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:130.0) Gecko/20100101 Firefox/130.0',
+            'Accept': '*/*',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Referer': 'https://inboxes.com/',
+            'Content-Type': 'application/json',
+            'DNT': '1',
+            'Sec-GPC': '1',
+            'Connection': 'close',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Priority': 'u=4'
+        }
+
+        return self.session.get(url, headers=headers).json()['html']

autowebx/mail_tm.py

@@ -0,0 +1,69 @@
+import time
+
+import requests
+from requests import JSONDecodeError
+
+from autoweb import AccountError
+from autoweb.account import Account
+
+
+def domains():
+    return [element['domain'] for element in requests.get('https://api.mail.tm/domains').json()['hydra:member']]
+
+
+class MailTMAccount(Account):
+
+    def __init__(
+            self, **kwargs
+    ):
+        super().__init__(**kwargs)
+        data = {
+            'address': self.email.lower(),
+            'password': self.password
+        }
+        while True:
+            try:
+                response = requests.post('https://api.mail.tm/accounts', json=data).json()
+                self.id = response['id']
+                break
+            except KeyError:
+                raise AccountError()
+            except JSONDecodeError:
+                pass
+        while True:
+            try:
+                token = requests.post('https://api.mail.tm/token', json=data).json()['token']
+                break
+            except JSONDecodeError:
+                pass
+        self.headers = {'Authorization': f"Bearer {token}"}
+
+    def messages(self, timeout: float = 30):
+        start = time.time()
+        while True:
+            while True:
+                try:
+                    response = requests.get('https://api.mail.tm/messages', headers=self.headers).json()
+                    break
+                except JSONDecodeError:
+                    pass
+                if time.time() - start > timeout:
+                    raise TimeoutError
+            if response['hydra:totalItems'] > 0:
+                messages = []
+                for member in response['hydra:member']:
+                    url = f'https://api.mail.tm/messages/{member["id"]}'
+                    while True:
+                        try:
+                            messages.append(requests.get(url, headers=self.headers).json()['html'])
+                            break
+                        except JSONDecodeError:
+                            pass
+
+                print(messages)
+                if response['hydra:totalItems'] == 1:
+                    return messages[0][0]
+                else:
+                    return messages[0]
+            if time.time() - start > timeout:
+                raise TimeoutError('No message received')

autowebx/mediafire.py

@@ -0,0 +1,18 @@
+import requests
+from bs4 import BeautifulSoup
+
+
+class File:
+    def __init__(self, file_id):
+        self.normal_download_link = f'https://www.mediafire.com/file/{file_id}/'
+
+    def __response__(self):
+        soup = BeautifulSoup(requests.get(self.normal_download_link).text, 'html.parser')
+        url = soup.find('a', attrs={'aria-label': "Download file"}).get('href')
+        return requests.get(url)
+
+    def content(self):
+        return self.__response__().content
+
+    def text(self):
+        return self.__response__().text

autowebx/panels.py

@@ -0,0 +1,161 @@
+from base64 import b64encode
+from datetime import datetime, timezone, timedelta
+from multiprocessing.connection import Client
+from multiprocessing.connection import Listener
+from threading import Thread, Lock
+from time import time
+
+import requests
+from requests import get
+
+
+class Premiumy:
+    __url = 'https://api.premiumy.net/v1.0/json'
+
+    def __init__(self, api_key: str, port: int = 3010):
+        self.__headers = {
+            "Content-type": "application/json",
+            "Api-Key": api_key
+        }
+
+        self.__data = {
+            "id": None,
+            "jsonrpc": "2.0",
+            "method": "sms.mdr_full:get_list",
+            "params": {
+                "filter": {
+                    "start_date": datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S'),
+                },
+            }
+        }
+
+        self.report = dict()
+        Thread(None, self.__report).start()
+
+        while True:
+            with Listener(('localhost', port)) as listener:
+                with listener.accept() as conn:
+                    conn.send(self.report)
+
+    def __report(self):
+        while True:
+            # noinspection PyBroadException
+            try:
+                response = requests.post(url=self.__url, json=self.__data, headers=self.__headers).json()
+                self.report.update({row['phone']: row['message'] for row in response['result']['mdr_full_list']})
+            except Exception:
+                pass
+
+
+class Sniper:
+    __url = "http://51.38.64.110/ints/agent/res/data_smscdr.php"
+
+    def __init__(self, phpsessid, port: int = 3010):
+        self.__headers = {
+            'X-Requested-With': 'XMLHttpRequest',
+            'Cookie': f'PHPSESSID={phpsessid}'
+        }
+
+        self.report = dict()
+        Thread(None, self.__report).start()
+
+        while True:
+            with Listener(('localhost', port)) as listener:
+                with listener.accept() as conn:
+                    conn.send(self.report)
+
+    def __report(self):
+        while True:
+            # noinspection PyBroadException
+            try:
+                parameters = {
+                    'fdate1': (datetime.now(timezone.utc) - timedelta(minutes=3)).strftime("%Y-%m-%d %H:%M:%S"),
+                    'fdate2': (datetime.now(timezone.utc) + timedelta(minutes=3)).strftime("%Y-%m-%d %H:%M:%S"),
+                }
+                response = requests.post(url=self.__url, params=parameters, headers=self.__headers).json()
+                self.report.update({row[2]: row[5] for row in response['aaData'][:-1]})
+            except Exception:
+                pass
+
+
+class PSCall:
+    __headers = {
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,'
+                  'application/signed-exchange;v=b3;q=0.7',
+        'Accept-Language': 'en-GB,en;q=0.9',
+        'Cache-Control': 'max-age=0',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
+                      'Chrome/131.0.0.0 Safari/537.36',
+    }
+
+    def __init__(self, key: str, port: int = 3010):
+        # noinspection HttpUrlsUsage
+        self.__url = f'http://pscall.net/restapi/smsreport?key={key}'
+        self.report = dict()
+        Thread(None, self.__report).start()
+        while True:
+            with Listener(('localhost', port)) as listener:
+                with listener.accept() as conn:
+                    conn.send(self.report)
+
+    def __report(self):
+        while True:
+            # noinspection PyBroadException
+            try:
+                response = get(self.__url, headers=PSCall.__headers, verify=False).json()
+                self.report.update({row['num']: row['sms'] for row in response['data']})
+            except Exception as _:
+                pass
+
+
+class Ziva:
+    def __init__(self, credentials, port: int = 3010):
+        self.__page_count = 0
+        self.__id = 0
+        auth = b64encode(credentials.encode('utf-8')).decode('utf-8')
+        self.__headers = {'Authorization': f'Basic {auth}'}
+        self.__url = 'http://zivastats.com/rest/sms?per-page=1000'
+        self.report = dict()
+        Thread(None, self.__report).start()
+        while True:
+            with Listener(('localhost', port)) as listener:
+                with listener.accept() as conn:
+                    conn.send(self.report)
+
+    def __report(self):
+        while True:
+            # noinspection PyBroadException
+            try:
+                response = get(self.__url, headers=self.__headers, verify=False)
+                response = response.json()
+                self.report.update({row['destination_addr']: row['short_message'] for row in response})
+            except Exception as _:
+                pass
+
+
+class ReportNotRunningError(Exception):
+    pass
+
+
+class ReportReader:
+    def __init__(self, port: int = 3010, timeout: int = 30):
+        self.port = port
+        self.__lock = Lock()
+        self.timeout = timeout
+
+    def message(self, number):
+        start = time()
+        while time() - start < self.timeout:
+            try:
+                with self.__lock:
+                    try:
+                        with Client(('localhost', 3010)) as conn:
+                            if result := conn.recv().get(number, None):
+                                return result
+                    except ConnectionRefusedError:
+                        raise ReportNotRunningError("Run the report script to receive messages from panels")
+            except ConnectionResetError:
+                pass
+        return None

autowebx/proxy.py

@@ -0,0 +1,51 @@
+import random
+
+
+# noinspection HttpUrlsUsage
+class Proxy:
+    def __init__(
+            self, text: str
+    ):
+        info = text.split('@')
+        if len(info) == 2:
+            authentication_information, self.server = info
+            self.username, self.password = authentication_information.split(':')
+        else:
+            info = text.split(':')
+            if len(info) == 2:
+                self.username = self.password = None
+                self.server = text
+            elif len(info) == 4:
+                self.username = info[2]
+                self.password = info[3]
+                self.server = f'{info[0]}:{info[1]}'
+            else:
+                raise TypeError(f"""Proxy must have one of the following formats:
+                                    username:password@proxyserver:port
+                                    proxy-server:port:username:password
+                                    proxy-server:port
+                                """)
+
+    def for_requests(self):
+        if self.username and self.password:
+            server = f'http://{self.username}:{self.password}@{self.server}'
+        else:
+            server = f'http://{self.server}'
+        return {"http": server, 'https': server}
+
+    def for_playwright(self):
+        return {
+            'server': f'http://{self.server}',
+            'username': self.username,
+            'password': self.password,
+        } if self.username and self.password else {'server': f'http://{self.server}'}
+
+
+class LunaProxy(Proxy):
+    __host_prefixes = ['pr', 'as', 'eu', 'na']
+
+    def __init__(self, username: str, password: str, region: str, session_time: int = 3):
+        super().__init__('0:0')
+        self.username = f'user-{username}-region-{region}-sesstime-{session_time}'
+        self.password = password
+        self.server = f'{random.choice(LunaProxy.__host_prefixes)}.6n3arhxy.lunaproxy.net:12233'

autowebx/remotix.py

@@ -0,0 +1,89 @@
+import json
+import os
+import random
+from socket import gethostname
+from threading import Thread
+from time import sleep
+from typing import Optional, Any
+
+from requests import post
+
+from autoweb.auto_save_dict import AutoSaveDict
+
+BASE_URL = 'http://localhost:8000'
+
+
+class InvalidKey(Exception):
+    pass
+
+class Run:
+    def __init__(self, key: str, stats: Optional[dict[str, Any]] = None,  *files: str):
+        base_dir = os.path.join(os.getenv("APPDATA"), 'Remotix')
+        if not os.path.exists(base_dir):
+            os.makedirs(base_dir)
+
+        file_path = os.path.join(base_dir, "data.json")
+        asd = AutoSaveDict(file_path)
+        if devic_id := asd.get('device_id', None):
+            url = f'{BASE_URL}/api/verify/?api_key={key}&device_id={devic_id}'
+            if not (response := post(url).json())['valid']:
+                raise InvalidKey(response['message'])
+        else:
+            device_name = gethostname()
+            url = f'{BASE_URL}/api/verify/?api_key={key}&device_name={device_name}'
+            asd['device_id'] = (response := post(url).json())['device_id']
+            if not response['valid']:
+                raise InvalidKey(response['message'])
+
+        url = f'{BASE_URL}/usage/'
+        data = {
+            'api_key': key,
+            'device_id': asd['device_id'],
+            'stats': json.dumps(stats),
+        }
+        self.__run_id = post(
+            url,
+            data=data,
+            files=[("files", (file.split('/')[-1], open(file, "rb"), "text/plain")) for file in
+                   files] if files else None
+        ).json()['run_id']
+
+        self.__key = key
+        self.__stats = dict()
+        self.__done = False
+
+        Thread(None, self.__log, 'log').start()
+
+    def __log(self):
+        while not self.__done:
+            # noinspection PyBroadException
+            try:
+                url = f'{BASE_URL}/usage/'
+                data = {
+                    'api_key': self.__key,
+                    'run_id': self.__run_id,
+                    'stats': json.dumps(self.__stats)
+                }
+                post(url, data=data)
+            except Exception:
+                pass
+
+    def log(self, key: str) -> None:
+        self.__stats[key] = self.__stats.get(key, 0) + 1
+
+    def done(self):
+        self.__done = True
+
+
+if __name__ == '__main__':
+    run = Run(
+        'bcab38ce-cd3a-4948-83f0-f577513a21e7',
+        {'threads': 3, 'total': 10}
+    )
+
+    for _ in range(1000):
+        run.log(random.choices(['Success', 'Fail'], weights=[90, 10], k=1)[0])
+        sleep(random.uniform(0, 1))
+
+    run.done()
+

autowebx/temp_mail.py

@@ -0,0 +1,50 @@
+import random
+
+from multipledispatch import dispatch
+from requests import get, post
+
+from autoweb.account import generate_username
+
+domains = [domain['name'] for domain in get("https://api.internal.temp-mail.io/api/v4/domains").json()['domains']]
+
+
+class Email:
+    @dispatch(str, str)
+    def __init__(self, name: str = generate_username(), domain: str = random.choice(domains)):
+        payload = {"name": name, "domain": domain}
+        response = post('https://api.internal.temp-mail.io/api/v3/email/new', json=payload).json()
+        self.address = response['email']
+        self.token = response['token']
+
+    @dispatch(int, int)
+    def __init__(self, min_name_length: int = 10, max_name_length: int = 10):
+        payload = {"min_name_length": min_name_length, "max_name_length": max_name_length}
+        response = post('https://api.internal.temp-mail.io/api/v3/email/new', json=payload).json()
+        self.address = response['email']
+        self.token = response['token']
+
+    @dispatch()
+    def __init__(self):
+        self.__init__(10, 10)
+
+    def get_messages(self):
+        return get_messages(self.address)
+
+
+def get_messages(email: str):
+    response = get(f'https://api.internal.temp-mail.io/api/v3/email/{email}/messages').json()
+    messages = [Message(message['id'], message['body_text'], message['body_html']) for message in response]
+    return messages[0] if len(messages) == 1 else messages
+
+
+class Message:
+    def __init__(self, id_: str, body_text: str, body_html: str):
+        self.id = id_
+        self.body_text = body_text
+        self.body_html = body_html
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        return other is Message and self.id == other.id