Я сменил аватарку! Поздравьте меня!

nedokoder · Воскресенье в 22:17

GOVARD Радуйся!

NeuralUser · Воскресенье в 22:20

Ну если у тебя такие фетиши, можешь конечно банку энергетика засунуть себе в задний проход

(игрушку не надо, пожалуйста)

jerrix · Понедельник в 07:56

Засунь акулу себе в задницу

zhanulka · Понедельник в 07:57

я бы порадовался за тебя но мне честно похуй
хотя не в принципе пиздатая аватарка, да и сам ты нормальный челик

я бы порадовался за тебя но честно похуй

хотя не в принципе пмздатая аватарка, и сам ты челик вроде нормальный

честно у меня какой то пиздец уже с сообщением я нихуя не понимаю

ааа ебучий югейс что происхоидт

ахаххаха ебал рот ну и даунизм

пиздец как эту хуйню убрать теперь говно говно залупа жопа

вчера с братком сидели, как вам?

ну ебаноый рот что с сообщением

а это люба из интернов. поставим лайк легенде?

если ктото знает как бабки вывести с пейпала скажите пожалуйста а то у меня там 3 доллара уже 2 года лежит

ловите мемчик пацаны чисто поржать перед сменой

ааа я еблан я вместо редактировать нажимал ответить аах0ааь сука ну я щебень

uwuparis · Понедельник в 08:23

монстер значит фембой

jerrix · Понедельник в 08:49

Оригинальный монстр для фембоев.
Белый монстр для настоящих мужчин(видел эдит

)

nedokoder · Понедельник в 13:22

оу

skiddedpvp · Понедельник в 14:09

дай старую аву

nedokoder · Понедельник в 14:17

Пожалуйста, зарегистрируйтесь или авторизуйтесь, чтобы увидеть содержимое.

uwuparis · Понедельник в 17:47

любой монстр равно фембой

skiddedpvp · Вторник в 05:32

Пожалуйста, зарегистрируйтесь или авторизуйтесь, чтобы увидеть содержимое.

M0nday · Вторник в 06:04

Я зашёл на форум, после глубокого инактива с июля, поздравлять не нужно, поскольку я скоро опять исчезну.

Похуй, зато после него мне было хорошо, поскольку поглотил еще таурина.

nedokoder · Вторник в 11:01

не стоит

Zlayamama · Вторник в 12:37

Шиттрэд, засунь банку (стеклянную) в жёпу.

coolfireofficial · Вторник в 12:39

желательно с петардой внутри что бы когда всунул она взорвалась

Zlayamama · Вчера в 00:55

Анальное кольцо без петарды всё сделает.

exdof · Вчера в 01:10

легенда из психбольницы номер 7

Привет, какое аниме посоветуешь?

honorbuddy · Вчера в 05:14

Парсер прокси

Код:

from bs4 import BeautifulSoup
import requests
import pandas as pd
from collections import defaultdict
from requests.exceptions import ConnectionError, Timeout, RequestException
from concurrent.futures import ThreadPoolExecutor, as_completed
import os

# Функция для проверки одного прокси по соответствующему протоколу
def check_proxy(proxy, proxy_type):
    url = "http://httpbin.org/ip" if proxy_type in ["HTTP", "HTTPS"] else "https://httpbin.org/ip"
    
    # Настраиваем прокси в зависимости от типа
    if proxy_type == "HTTP":
        proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
    elif proxy_type == "HTTPS":
        proxies = {"https": f"https://{proxy}"}
    elif proxy_type == "SOCKS4":
        proxies = {"http": f"socks4://{proxy}", "https": f"socks4://{proxy}"}
    elif proxy_type == "SOCKS5":
        proxies = {"http": f"socks5://{proxy}", "https": f"socks5://{proxy}"}
    else:
        print(f"Неизвестный тип прокси: {proxy_type}")
        return None

    try:
        response = requests.get(url, proxies=proxies, timeout=5)
        if response.status_code == 200:
            print(f"Прокси {proxy} ({proxy_type}) работает.")
            return proxy  # Возвращаем рабочий прокси, если он доступен
        else:
            print(f"Прокси {proxy} ({proxy_type}) не работает. Код ответа: {response.status_code}")
            return None
    except (ConnectionError, Timeout) as e:
        print(f"Прокси {proxy} ({proxy_type}) недоступен. Ошибка подключения: {e}")
        return None
    except RequestException as e:
        print(f"Прокси {proxy} ({proxy_type}) недоступен. Ошибка: {e}")
        return None

# Функция для получения прокси из файла
def get_proxies_from_file(filename):
    try:
        # Выводим абсолютный путь для проверки
        print(f"Пытаемся открыть файл: {os.path.abspath(filename)}")

        if os.path.exists(filename):
            with open(filename, 'r') as file:
                proxies = [line.strip() for line in file.readlines()]
            return proxies
        else:
            print(f"Файл {filename} не найден.")
            return []
    except Exception as e:
        print(f"Ошибка при чтении файла с прокси: {e}")
        return []



# Функция для проверки списка прокси в многопоточном режиме
def check_proxies_concurrently(proxy_list, max_threads=15):
    working_proxies = []

    with ThreadPoolExecutor(max_workers=max_threads) as executor:
        futures = {executor.submit(check_proxy, proxy, proxy_type): (proxy, proxy_type) for proxy, proxy_type in proxy_list}
        
        for future in as_completed(futures):
            result = future.result()
            if result:  # Если прокси рабочий, добавляем в список
                working_proxies.append(result)
    
    return working_proxies

# Функция для сбора и проверки прокси с использованием многопоточности
def collect_and_check_proxies(max_proxies=1500, max_threads=15, min_speed=1000, proxy_file="work_proxy.txt"):
    rows = []
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0"}

    # Получаем прокси из файла, если файл существует
    proxy_list = get_proxies_from_file(proxy_file)

    # Если файл пустой, используем стандартные прокси-серверы
    if not proxy_list:
        print("Файл с прокси пуст или не найден. Используем стандартные запросы.")
        proxy_list = []

    def fetch_proxies_using_proxy(proxy):
        """Функция для сбора прокси через указанный прокси."""
        rows_temp = []
        try:
            url = f"https://hidexn.name/proxy-list/?start=0#"
            proxies = {"http": f"http://{proxy}", "https": f"http://{proxy}"}
            response = requests.get(url, headers=headers, proxies=proxies, timeout=5)
            if response.status_code == 200:
                soup = BeautifulSoup(response.text, "html.parser")
                table_rows = soup.select('table tbody tr')
                
                for row in table_rows:
                    cols = row.find_all('td')
                    ip_address = cols[0].text.strip()
                    port = cols[1].text.strip()
                    country = cols[2].select_one('.country').text.strip()
                    city = cols[2].select_one('.city').text.strip() if cols[2].select_one('.city') else ''
                    speed = cols[3].select_one('p').text.strip()
                    connection_type = cols[4].text.strip()
                    anonymity = cols[5].text.strip()
                    last_update = cols[6].text.strip()

                    rows_temp.append({
                        'IP адрес': ip_address,
                        'Порт': port,
                        'Страна': country,
                        'Город': city,
                        'Скорость': speed,
                        'Тип': connection_type,
                        'Анонимность': anonymity,
                        'Последнее обновление': last_update
                    })
        except Exception as e:
            print(f"Ошибка при использовании прокси {proxy}: {e}")
        return rows_temp
    
    # Многопоточный сбор прокси с использованием прокси из файла
    all_rows = []
    if proxy_list:
        with ThreadPoolExecutor(max_workers=max_threads) as executor:
            futures = {executor.submit(fetch_proxies_using_proxy, proxy): proxy for proxy in proxy_list}
            for future in as_completed(futures):
                all_rows.extend(future.result())

    # Если прокси не было в файле, собираем стандартные прокси
    if not proxy_list or len(all_rows) < max_proxies:
        for value in range(0, 12672, 64):
            try:
                if len(all_rows) >= max_proxies:
                    break

                url = f"https://hidexn.name/proxy-list/?start={value}#"
                response = requests.get(url=url, headers=headers)
                if response.status_code == 200:
                    soup = BeautifulSoup(response.text, "html.parser")
                    table_rows = soup.select('table tbody tr')

                    for row in table_rows:
                        cols = row.find_all('td')
                        ip_address = cols[0].text.strip()
                        port = cols[1].text.strip()
                        country = cols[2].select_one('.country').text.strip()
                        city = cols[2].select_one('.city').text.strip() if cols[2].select_one('.city') else ''
                        speed = cols[3].select_one('p').text.strip()
                        connection_type = cols[4].text.strip()
                        anonymity = cols[5].text.strip()
                        last_update = cols[6].text.strip()
                        speed_value = int(speed.replace("мс", "").strip())

                        if(speed_value <= min_speed):
                            all_rows.append({
                            'IP адрес': ip_address,
                            'Порт': port,
                            'Страна': country,
                            'Город': city,
                            'Скорость': speed,
                            'Тип': connection_type,
                            'Анонимность': anonymity,
                            'Последнее обновление': last_update
                            })
            except Exception as e:
                print(f"An exception occurred: {e}")

    # Ограничиваем количество прокси
    all_rows = all_rows[:max_proxies]

    # Список IP:порт и их типа для проверки
    proxy_list_for_check = [(f"{row['IP адрес']}:{row['Порт']}", row['Тип']) for row in all_rows]

    # Параллельная проверка прокси
    working_proxies = check_proxies_concurrently(proxy_list_for_check, max_threads=max_threads)

    # Группируем рабочие прокси по странам и типу
    proxies_by_country_and_type = defaultdict(lambda: defaultdict(list))
    for row in all_rows:
        ip_port = f"{row['IP адрес']}:{row['Порт']}"
        if ip_port in working_proxies:
            country = row["Страна"]
            connection_type = row["Тип"]
            proxies_by_country_and_type[country][connection_type].append(ip_port)

    # Записываем проверенные прокси в файлы по странам и типам
    for country, types in proxies_by_country_and_type.items():
        for connection_type, proxies in types.items():
            # Создаем директорию для каждого типа соединения в каждой стране
            directory = os.path.join(country, connection_type)
            os.makedirs(directory, exist_ok=True)
            filename = os.path.join(directory, f"{country}_{connection_type}_proxy.txt")
            
            with open(filename, "w") as file:
                for proxy in proxies:
                    file.write(proxy + "\n")

    # Создаем DataFrame из собранных данных и выводим
    df = pd.DataFrame(all_rows)
    print(df)

# Пример вызова с указанием количества потоков и максимального количества прокси
max_threads = int(input("Введите количество потоков: "))  # Количество потоков
max_proxies = int(input("Введите максимальное количество прокси: "))  # Максимальное количество прокси
min_speed   = int(input("Введите минимальную скорость для прокси: "))
collect_and_check_proxies(max_proxies=max_proxies, max_threads=max_threads, min_speed=min_speed)

zhanulka · Сегодня в 00:33

2 дня мне дайте