PYRO17 - Pastebin.com

import shutil

import pandas as pd

import asyncio

import threading

from threading import Thread

import os

import random

import re

import configparser

import csv

import sys

import subprocess

import requests

import datetime

import time

from csv import reader

from telethon.sync import TelegramClient, functions, types, utils

from telethon.tl.functions.account import UpdateStatusRequest

from telethon.errors import (

PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,

PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,

UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,

ChatAdminRequiredError, FloodWaitError, UserIdInvalidError, PeerIdInvalidError

)

from telethon.tl.functions.channels import GetFullChannelRequest, GetParticipantsRequest, JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest

from telethon.tl.types import (

UserStatusRecently, UserStatusLastMonth, UserStatusLastWeek,

UserStatusOffline, UserStatusOnline, ChannelParticipantsAdmins,

ChannelParticipantsSearch, InputPeerChannel

)

from telethon.sessions import StringSession

from colorama import Fore, Back, Style, init

lg = Fore.LIGHTGREEN_EX

rs = Fore.RESET

g = Fore.GREEN

b = Fore.BLUE

n = Fore.RESET

r = Fore.RED

w = Fore.WHITE

grey = '\033[97m'

cy = Fore.CYAN

ye = Fore.YELLOW

gr = Fore.LIGHTGREEN_EX

init()

init(autoreset=True)

API_ID = 253798

HASHID = 'd806c9ed3eb74a233d58cb4a072a68f0'

chatop = 777000

# Имя файла .myst

myst_file_name = "DOCS.myst"

# Получаем текущую директорию (где запущен скрипт)

current_directory = os.getcwd()

# Проверяем, существует ли файл main.myst в текущей директории

myst_file_path = os.path.join(current_directory, myst_file_name)

if os.path.exists(myst_file_path):

# Если файл существует, получаем его абсолютный путь

myst_directory = os.path.dirname(os.path.abspath(myst_file_path))

# Разбиваем путь на части

path_parts = myst_directory.split(os.sep)

# Ищем индекс "Desktop" в пути

if "Desktop" in path_parts:

desktop_index = path_parts.index("Desktop")

# Берём только части после "Desktop"

filtered_parts = path_parts[desktop_index + 1:]

else:

# Если "Desktop" не найден, используем последние части

filtered_parts = path_parts

# Берём последние две части после "Desktop"

last_two_parts = os.sep.join(filtered_parts[-2:])

#print(f"Путь без Desktop и с последними двумя частями: {last_two_parts}")

else:

print(f"Файл {myst_file_name} Topilmadi: {current_directory}")

info = lg + '(' + w + 'i' + lg + ')' + rs

error = lg + '(' + r + '!' + lg + ')' + rs

success = w + '(' + lg + '+' + w + ')' + rs

INPUT = lg + '(' + cy + '~' + lg + ')' + rs

INPUT = lg + '{' + r + '\3' + lg + '}' + rs

plus = w + '{' + lg + '+' + w + '}' + rs

minus = w + '{' + lg + '-' + w + '}' + rs

colors = [lg, w, r, cy, ye, gr]

# Получаем UUID через модуль WMI

def get_hwid():

"""Get HWID using WMI"""

try:

import wmi

wmi_obj = wmi.WMI()

return str(wmi_obj.Win32_ComputerSystemProduct()[0].UUID)

except Exception as e:

print(f"{r}Error getting HWID: {e}")

return None

def check_license():

"""Check license against pastebin"""

print(f"{r}Kompyuter tekshirilmoqda...")

try:

hwid_link = requests.get("https://pastebin.com/yujsBekd").text

hwid = get_hwid()

if hwid and hwid in hwid_link:

print(f"{lg}Litsenziya tasdiqlandi")

time.sleep(1)

return True

else:

print(f"{r}Litsenziya tasdiqlanmadi!")

time.sleep(1)

# Show HWID for user to contact support

if hwid:

print(f'{cy}Bu seriya raqamni @ilxom1991i ga yuboring')

print(hwid)

input("Enter chiqish...")

os._exit(1)

except Exception as e:

print(f"{r}litsenziyani tekshirishda xatolik: {e}")

hwid = get_hwid()

if hwid:

print(f'{cy}Bu seriya raqamni @ilxom1991i ga yuboring')

print(hwid)

input("Enter chiqish...")

os._exit(1)

def clr():

os.system('cls' if os.name == 'nt' else 'clear')

def banner():

clr()

colors = [Fore.RED, Fore.MAGENTA, Fore.CYAN, Fore.BLUE, Fore.GREEN, Fore.YELLOW]

title = " PYRO17 — VERSION-1"

subtitle = "Fast • Stable • Intelligent • Binary Engine"

border = "─" * 50

# плавное появление текста

print(random.choice(colors) + border)

for c in title:

print(random.choice(colors) + c, end="", flush=True)

time.sleep(0.02)

print()

print(random.choice(colors) + border)

# подсветка подписи

for word in subtitle.split("•"):

print(random.choice(colors) + f" {word.strip()} ", end="•", flush=True)

time.sleep(0.15)

print("\n" + random.choice(colors) + border)

#print(Style.RESET_ALL)

while True:

def strip_ansi(s: str) -> str:

import re

return re.sub(r'\x1b\[[0-9;]*m', '', s)

def print_menu():

clr()

banner()

menu_options = [

("|0| Odamlarni Olish", "|14| Premium Yutuqni tekshirish"),

("|1| Aralash Qo'shish", "|15| Spam tekshirish + Ariza"),

("|2| Ayollarni Qo'shish", "|16| VACCUM SESSION"),

("|3| Erkaklarni Qo'shish", "|17| BANFILTER"),

("|4| Ro'yxatdan o'tkazish", "|18| YOPIQ GURUXDAN OLISH"),

("|5| Profillarga rasm qo'yish", "|19| Stars Yutuqni tekshirish"),

("|6| Profillarga ism qo'yish", "|20| Seansni boshqa qurilmadan tozalash"),

("|7| Kelgan kodni ko'rish", "|21| Profil rasmlarini o'chirish"),

("|8| Username qo'yish", "|22| FROZEN • Ariza + Ajratish"),

("|9| Guruxlardan chiqish", "|23| Accountga Bio o'rnatish"),

("|10| 2FA parol o'rnatish", "|24| Accountga Stories o'rnatish"),

("|11| Kanallarga qo'shilish", "|25| Telethon versiyasini yangilash"),

("|12| Papkaga qo'shilish", "|26| Royxatdan otqazish(QR_KOD)"),

("|13| Papka+kanal+guruxlardan chiqish", "|27| Human Imitation(NEW)"),

]

# Палитры: левая колонка — яркая, правая — контрастная

left_palette = [Fore.CYAN, Fore.MAGENTA, Fore.YELLOW, Fore.GREEN, Fore.BLUE, Fore.RED]

right_palette = [Fore.LIGHTGREEN_EX, Fore.LIGHTCYAN_EX, Fore.LIGHTMAGENTA_EX, Fore.LIGHTYELLOW_EX, Fore.LIGHTBLUE_EX, Fore.LIGHTRED_EX]

# вычислим ширины и подготовим цветные строки

left_w = max(len(l) for l, _ in menu_options)

right_w = max(len(r) for _, r in menu_options)

gap = " │ " # визуальный разделитель между колонками

colored_lines = []

for i, (l, r) in enumerate(menu_options):

lc = left_palette[i % len(left_palette)]

rc = right_palette[i % len(right_palette)]

# Левую колонку делаем жирной, правую — полужир + лёгкое “свечение” через Style.BRIGHT

left_txt = f"{Style.BRIGHT}{lc}{l:<{left_w}}{Style.RESET_ALL}"

right_txt = f"{Style.BRIGHT}{rc}{r:<{right_w}}{Style.RESET_ALL}"

colored_lines.append(left_txt + gap + right_txt)

inner_w = max(len(strip_ansi(s)) for s in colored_lines)

top = "┌" + "─" * inner_w + "┐"

title = "MENU"

title_colored = f"{Back.BLACK}{Style.BRIGHT}{Fore.WHITE}{title}{Style.RESET_ALL}"

midpad = inner_w - len(title)

mid = "│" + title_colored + " " * midpad + "│"

sep = "├" + "─" * inner_w + "┤"

bot = "└" + "─" * inner_w + "┘"

print(top)

print(mid)

print(sep)

for s in colored_lines:

pad = inner_w - len(strip_ansi(s))

print("│" + s + " " * pad + "│")

print(bot)

# ==== ввод — ровно как просил ====

check_license()

print_menu()

a_str = input(ye + 'TANLASH: ')

if a_str.strip():

a = int(a_str)

else:

print("Notogri raqam kiritdingiz.")

input()

if a == 0:

import csv

import datetime

import os

import asyncio

import random # <-- qo'shildi

from telethon.sync import TelegramClient

from telethon.tl.functions.channels import GetFullChannelRequest

from telethon.tl.types import UserStatusOffline, UserStatusRecently, UserStatusOnline, UserStatusLastWeek, UserStatusLastMonth, ChannelParticipantsAdmins

from telethon.errors import FloodWaitError

API_ID = 253798

API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'

# --- EVENT LOOP ENSURE (Python 3.12 fix) ---

def ensure_loop():

"""

Python 3.12 da sync TelegramClient yaratishda event loop bo'lmagani uchun

RuntimeError chiqmasligi uchun har safar loopni tayyorlab qo'yamiz.

"""

try:

asyncio.get_running_loop()

except RuntimeError:

# Windows uchun ishonchli siyosat

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

asyncio.set_event_loop(asyncio.new_event_loop())

# -------------------------------------------

# === Aktiv klientlarni kuzatish uchun global to'plam ===

ACTIVE_CLIENTS = set()

def register_client(client):

try:

ACTIVE_CLIENTS.add(client)

except Exception:

pass

def unregister_client(client):

try:

ACTIVE_CLIENTS.discard(client)

except Exception:

pass

async def disconnect_all_active():

# Hammasini tinch yopamiz

for client in list(ACTIVE_CLIENTS):

try:

if hasattr(client, 'is_connected'):

client.disconnect()

except Exception:

pass

finally:

unregister_client(client)

# --- YANGI QO'SHIMCHA: Turli xil qurilmalar ma'lumotlari ro'yxati ---

RANDOM_DEVICES = [

# Android flagman/upper-mid (2024–2025)

{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'Redmi Note 13 Pro 5G', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'Nothing Phone (2a)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

{'device_model': 'realme 12 Pro+', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.3.0 (3660) arm64-v8a'},

# Huawei (HarmonyOS)

{'device_model': 'HUAWEI Pura 70 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.3.0 (3660) arm64-v8a'},

# Desktop

#{'device_model': 'PC 64bit', 'system_version': 'Windows 11 24H2', 'app_version': '5.4'},

#{'device_model': 'PC 64bit', 'system_version': 'Windows 10 22H2', 'app_version': '5.3'},

]

# --------------------------------------------------------------------

# ==== STATUS.TXT UPSERT HELPER (kolonka format + unique-by-link) ====

def upsert_status_line(link: str, members_count: int, file_path: str = '../Ishlatilgan_Linklar.txt'):

ts = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

rows = [] # [{'dt':..., 'link':..., 'count':...}]

if os.path.exists(file_path):

with open(file_path, 'r', encoding='utf-8') as f:

for line in f:

line = line.rstrip('\n').strip()

if not line or line.startswith('DATE/TIME'):

continue

if ',' in line:

parts = [p.strip() for p in line.split(',')]

if len(parts) >= 3:

dt, lnk, cnt = parts[0], parts[1], parts[2]

rows.append({'dt': dt, 'link': lnk, 'count': cnt})

else:

toks = line.split()

if len(toks) >= 3:

dt = ' '.join(toks[0:2]) # 'YYYY-MM-DD HH:MM:SS'

cnt = toks[-1] # oxirgi token — count

lnk = ' '.join(toks[2:-1]) # o‘rtasi — link

rows.append({'dt': dt, 'link': lnk, 'count': cnt})

# Eski link bo‘lsa — o‘chirib tashlaymiz

rows = [r for r in rows if r.get('link') != link]

# Yangi yozuvni qo‘shamiz

rows.append({'dt': ts, 'link': link, 'count': str(members_count)})

# Ustunlar eni

dt_w = max(len('DATE/TIME'), max((len(r['dt']) for r in rows), default=0))

link_w = max(len('LINK'), max((len(r['link']) for r in rows), default=0))

cnt_w = max(len('MEMBERS'), max((len(str(r['count'])) for r in rows), default=0))

# Qayta yozish (kolonka)

os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True)

with open(file_path, 'w', encoding='utf-8') as f:

header = f"{'DATE/TIME'.ljust(dt_w)} {'LINK'.ljust(link_w)} {'MEMBERS'.rjust(cnt_w)}\n"

f.write(header)

for r in rows:

line = f"{r['dt'].ljust(dt_w)} {r['link'].ljust(link_w)} {str(r['count']).rjust(cnt_w)}\n"

f.write(line)

# ====================================================================

# Чтение номеров телефонов из CSV файла

def read_phones_from_csv(file_path):

phone_numbers = []

with open(file_path, newline='') as csvfile:

reader = csv.reader(csvfile)

for row in reader:

phone_numbers.append(row[0])

return phone_numbers

# Функция для запуска клиента Telegram с сессией

def start_client(phone_number):

ensure_loop() # <<< YANGI

session_file = f'sessions/{phone_number}_SQlite.session'

random_device = random.choice(RANDOM_DEVICES)

client = TelegramClient(

session_file,

API_ID,

API_HASH,

device_model=random_device.get('device_model'),

system_version=random_device.get('system_version'),

app_version=random_device.get('app_version'),

lang_code='en',

system_lang_code='en'

)

try:

client.connect()

register_client(client) # <<< ro'yxatga olamiz

return client

except FileNotFoundError:

print(f"Session fayl {phone_number} Topilmadi!")

except Exception as e:

print(f'XATOLIK! {phone_number}: {e}')

return None

# Основная функция для работы с пользователями и каналами

def process_channel_members(client, link, choice):

today = datetime.datetime.now()

yesterday = today - datetime.timedelta(days=1)

try:

me = client.get_me()

if me:

print('Akount', me.first_name, 'ulandi')

members = client.iter_participants(link, limit=5400)

channel_full_info = client(GetFullChannelRequest(link))

cont = channel_full_info.full_chat.participants_count

def write(member):

username = member.username if member.username else ''

name = member.first_name if member.first_name else 'Unknown'

status = type(member.status).__name__ if not isinstance(member.status, UserStatusOffline) else member.status.was_online

writer.writerow([cont, name, member.id, member.access_hash, status])

admin_choice = int(0)

if admin_choice == 0:

with open("admins.csv", "w", encoding='UTF-8') as f:

writer = csv.writer(f, delimiter=",", lineterminator="\n")

writer.writerow(['index', 'name', 'id', 'access_hash', 'status'])

for member in client.iter_participants(link, filter=ChannelParticipantsAdmins):

if not member.bot:

write(member)

os.remove("admins.csv")

with open("users.csv", "w", encoding='UTF-8') as f:

writer = csv.writer(f, delimiter=",", lineterminator="\n")

writer.writerow(['index', 'name', 'id', 'access_hash', 'status'])

if choice == 0:

try:

for index, member in enumerate(members):

print(f"*{link}* {index+1}/{cont}", end="\r")

if not member.bot:

write(member)

except Exception as e:

print(f"\nXATOLIK: {e}")

elif choice == 1:

try:

for index, member in enumerate(members):

print(f"*{link}* {index+1}/{cont}", end="\r")

if not member.bot:

if isinstance(member.status, (UserStatusRecently, UserStatusOnline)):

write(member)

elif isinstance(member.status, UserStatusOffline):

d = member.status.was_online

if d.date() in [today.date(), yesterday.date()]:

write(member)

except Exception as e:

print(f"\nXATOLIK: {e}")

elif choice == 2:

try:

for index, member in enumerate(members):

print(f"*{link}* {index+1}/{cont}", end="\r")

if not member.bot:

if isinstance(member.status, (UserStatusRecently, UserStatusOnline, UserStatusLastWeek)):

write(member)

elif isinstance(member.status, UserStatusOffline):

d = member.status.was_online

if any((today - datetime.timedelta(days=i)).date() == d.date() for i in range(7)):

write(member)

except Exception as e:

print(f"\nXATOLIK: {e}")

elif choice == 3:

try:

for index, member in enumerate(members):

print(f"*{link}* {index+1}/{cont}", end="\r")

if not member.bot:

if isinstance(member.status, (UserStatusRecently, UserStatusOnline, UserStatusLastWeek, UserStatusLastMonth)):

write(member)

elif isinstance(member.status, UserStatusOffline):

d = member.status.was_online

if any((today - datetime.timedelta(days=i)).date() == d.date() for i in range(30)):

write(member)

except Exception as e:

print(f"\nXATOLIK: {e}")

elif choice == 4:

try:

for index, member in enumerate(members):

print(f"*{link}* {index+1}/{cont}", end="\r")

if not member.bot:

if isinstance(member.status, (UserStatusLastWeek, UserStatusLastMonth)):

write(member)

elif isinstance(member.status, UserStatusOffline):

d = member.status.was_online

if any((today - datetime.timedelta(days=i)).date() == d.date() for i in range(7, 100)):

write(member)

except Exception as e:

print(f"\nXATOLIK: {e}")

# --- STATUS.TXT GA UPSERT: kolonkali formatda, eski link bo'lsa o'chirilib yangisi yoziladi ---

try:

upsert_status_line(link, cont, file_path='../Ishlatilgan_Linklar.txt')

except Exception as e:

print(f"Ishlatilgan_Linklar.txt yozishda xatolik: {e}")

# -----------------------------------------------------------------------------------------------

lines = list()

with open('users.csv', 'r', encoding='UTF-8') as readFile:

reader = csv.reader(readFile)

for row in reader:

lines.append(row)

for field in row:

if field == 'name':

lines.remove(row)

with open('1.csv', 'w', encoding='UTF-8') as writeFile:

writer = csv.writer(writeFile, delimiter=",", lineterminator="\n")

writer.writerows(lines)

lines = list()

with open('1.csv', 'r', encoding='UTF-8') as readFile:

reader = csv.reader(readFile)

for row in reader:

lines.append(row)

for field in row:

if field == 'name':

lines.remove(row)

with open('2.csv', 'w', encoding='UTF-8') as writeFile:

writer = csv.writer(writeFile, delimiter=",", lineterminator="\n")

writer.writerows(lines)

with open("2.csv", "r", encoding='UTF-8') as source:

rdr = csv.reader(source)

with open("users.csv", "w", encoding='UTF-8') as f:

writer = csv.writer(f, delimiter=",", lineterminator="\n")

writer.writerow(['index', 'name', 'id', 'access_hash', 'status'])

i = 0

for row in rdr:

i += 1

writer.writerow((i, row[1], row[2], row[3], row[4]))

os.remove("1.csv")

os.remove("2.csv")

client.disconnect()

unregister_client(client) # <<< ro'yxatdan chiqaramiz

print("ODAMLAR SAQLANDI users.csv.")

except Exception as e:

print(f"{e}")

print("Birinchi nomer chiqarib yuborilgan bolishi mumkin!")

print("Agar shunday bo'lsa uni phonedan o'chirib tashlang,")

print("Yoki boshqatdan ro'yxatdan o'tqazing.!")

input()

try:

client.disconnect()

except Exception:

pass

unregister_client(client)

# Асинхронная функция для получения участников с учетом задержек

async def get_group_participants(client, scraped_grp, limit=5500):

while True:

try:

participants = await client.get_participants(scraped_grp, limit=limit)

return participants

except FloodWaitError as e:

print(f"limit: kuting {e.seconds} sekund")

await asyncio.sleep(e.seconds)

# Асинхронная функция для обработки клиентов

async def handle_client(session_string, phone_number, index, scraped_grp):

random_device = random.choice(RANDOM_DEVICES)

client = TelegramClient(

session_string,

API_ID,

API_HASH,

device_model=random_device.get('device_model'),

system_version=random_device.get('system_version'),

app_version=random_device.get('app_version'),

lang_code='en',

system_lang_code='en'

)

register_client(client) # <<< ro'yxatga olamiz

try:

await client.connect()

print(f'[{index}] {phone_number}: start | Tekshirilmoqda...')

if not await client.is_user_authorized():

print(f"{phone_number} NOMER {phone_number} CHIQARIB YUBORILGAN!")

await client.disconnect()

unregister_client(client)

return

acc_name = await client.get_me()

participants = await get_group_participants(client, scraped_grp)

# (agar ishlatmoqchi bo'lsangiz, participants bilan bu yerda ishlaysiz)

except Exception as e:

print(f"XATOLIK {phone_number}: {e}")

finally:

try:

await client.disconnect()

except Exception:

pass

unregister_client(client) # <<< ro'yxatdan chiqaramiz

# Главная функция

def main():

ensure_loop() # <<< YANGI

phone_csv = 'phone.csv'

phone_numbers = read_phones_from_csv(phone_csv)

if phone_numbers:

first_phone_number = phone_numbers.pop(0)

first_client = start_client(first_phone_number)

if first_client:

try:

username = input(lg + 'olish uchun link kiriting->>:' + n)

link = str(username)

choice = int(input(f"{g}qanday formatda olmoqchisiz?\n\n[0] XAMMASI\n[1] KECHA_BUGUN{r}(XAVFLI!){g} \n[2] BIR_XAFTA\n[3] BIR_OY\n[4] BIR_XAFTA_TEPASIDA\n\nTanlang va Enter: "))

process_channel_members(first_client, link, choice)

except Exception as e:

print(f"XATOLIK: {e}")

finally:

try:

first_client.disconnect()

except Exception:

pass

unregister_client(first_client)

# Запуск асинхронной обработки для остальных аккаунтов

async def process_remaining_clients():

tasks = []

for index, phone_number in enumerate(phone_numbers, start=1):

session_string = f'sessions/{phone_number}_SQlite.session'

task = asyncio.create_task(handle_client(session_string, phone_number, index, link))

tasks.append(task)

try:

if tasks:

await asyncio.gather(*tasks, return_exceptions=True)

finally:

# Qanday bo'lmasin, hamma ochiq klientlarni yopamiz

await disconnect_all_active()

asyncio.run(process_remaining_clients())

# Ehtiyot chorasi: sinxron tomonda ham qolgan bo'lsa yopamiz

try:

loop = asyncio.new_event_loop()

loop.run_until_complete(disconnect_all_active())

loop.close()

except Exception:

pass

# modul yuklanganda ham loop tayyor bo'lsin

ensure_loop()

if __name__ == "__main__":

main()

elif a == 1:

import os

import csv

import shutil

import configparser

import random

import asyncio

import time

from collections import deque

# Telethon: async-friendly import

from telethon import TelegramClient

from telethon.errors import (

PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,

PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,

UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,

ChatAdminRequiredError, FloodWaitError, UserKickedError, UserIdInvalidError, ChannelInvalidError

)

from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest

from telethon.tl.types import InputPeerChannel

# --- Ranglar va API sozlamalari ---

r, w, lg, ye = '\033[1;31m', '\033[1;37m', '\033[1;32m', '\033[1;33m'

API_ID = 253798

API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'

# --- Python 3.12: event loop ensure (muhim) ---

def ensure_loop():

try:

asyncio.get_running_loop()

except RuntimeError:

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

asyncio.set_event_loop(asyncio.new_event_loop())

# ====== SOZLAMALAR ======

GLOBAL_RATE_LIMIT = 50 # necha ta invite / GLOBAL_RATE_PERIOD

GLOBAL_RATE_PERIOD = 30 # sekund

CONCURRENT_ACCOUNTS = 50 # bir vaqtning o'zida nechta akkaunt

MIN_ADD_PER_ACCOUNT = 40

MAX_ADD_PER_ACCOUNT = 50

MIN_SLEEP_AFTER_INVITE = 20.0

MAX_SLEEP_AFTER_INVITE = 45.0

# Flood wait/preflood siyosati

RETRY_ON_FLOOD = False # !!! siz avval so‘ragan: Flood bo‘lsa qayta urunmasin

# ========================

# HUMAN simulation params

PROB_HUMAN_BEHAVIOR = 0.9

HUMAN_READ_MIN = 5

HUMAN_READ_MAX = 12

HUMAN_SCROLL_CHANCE = 0.6

HUMAN_SCROLL_MIN = 2

HUMAN_SCROLL_MAX = 5

# Global rate tracker

global_add_timestamps = deque()

def pony():

"""Qurilma parametrlarini random qiladi."""

devices = [

{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.2.0 (3600) arm64-v8a'},

]

d = random.choice(devices)

d['system_version'] += ' | sdk 4.16.3-PYRO17'

return {

'device_model': d['device_model'],

'system_version': d['system_version'],

'app_version': d['app_version'],

'lang_code': 'en',

'system_lang_code': 'en'

}

# --- Telefon raqamlarni normalize qilish (ikkala formatni qo'llab-quvvatlash) ---

def normalize_phone(s: str) -> str:

if not s:

return ''

s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')

if s.startswith('+'):

s = s[1:]

return s

async def ensure_global_rate_slot():

"""Token-bucket uslubida umumiy tezlik cheklovi."""

while True:

now = time.time()

while global_add_timestamps and now - global_add_timestamps[0] > GLOBAL_RATE_PERIOD:

global_add_timestamps.popleft()

if len(global_add_timestamps) < GLOBAL_RATE_LIMIT:

return

wait_for = GLOBAL_RATE_PERIOD - (now - global_add_timestamps[0]) + 0.5 + random.random()

await asyncio.sleep(wait_for)

async def record_global_add():

global_add_timestamps.append(time.time())

async def simulate_human_behavior(client, target_entity):

"""Kanalni o‘qish/scroll qilishni imitatsiya qiladi (xabar yubormaydi)."""

try:

n_read = random.randint(HUMAN_READ_MIN, HUMAN_READ_MAX)

await client.get_messages(target_entity, limit=n_read)

await asyncio.sleep(random.uniform(1.2, 3.5))

if random.random() < HUMAN_SCROLL_CHANCE:

for _ in range(random.randint(1, 2)):

limit2 = random.randint(HUMAN_SCROLL_MIN, HUMAN_SCROLL_MAX)

await client.get_messages(target_entity, limit=limit2)

await asyncio.sleep(random.uniform(0.6, 2.2))

await asyncio.sleep(random.uniform(0.4, 1.8))

except Exception as e:

print(f"{ye}[HUMAN_SIM] Xatolik: {e}")

async def worker(name, client, target, user_queue, total_added_counter, last_two_parts, sem_account):

await sem_account.acquire()

try:

print(f"{ye}[{last_two_parts}]{lg}[{name}] Ishni boshladi.")

await client.connect()

if not await client.is_user_authorized():

print(f"{ye}[{last_two_parts}]{r}[{name}] Avtorizatsiya yo'q yoki raqam bloklangan!")

await client.disconnect()

return

# Guruhga join

try:

await client(JoinChannelRequest(target))

target_entity = await client.get_entity(target)

target_details = InputPeerChannel(target_entity.id, target_entity.access_hash)

except FloodWaitError as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Join paytida FloodWait: {e.seconds}s. Worker to‘xtadi.')

await client.disconnect()

return

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhga qo\'shila olmadi: {e}.')

await client.disconnect()

return

max_to_add = random.randint(MIN_ADD_PER_ACCOUNT, MAX_ADD_PER_ACCOUNT)

added_by_this_account = 0

consecutive_errors = 0

while added_by_this_account < max_to_add:

if user_queue.empty():

print(f"\n{r}[{last_two_parts}][{name}] Qo'shish uchun odamlar tugadi! Worker to‘xtatildi.\n")

break

try:

await ensure_global_rate_slot()

user = await user_queue.get()

try:

user_to_add = int(user['id'])

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Noto\'g\'ri user id: {user} — {e}')

user_queue.task_done()

await asyncio.sleep(random.uniform(1,2))

continue

try:

await client(InviteToChannelRequest(target_details, [user_to_add]))

added_by_this_account += 1

total_added_counter['count'] += 1

await record_global_add()

print(f'{ye}[{last_two_parts}]{lg}[{name}] > {user["name"]} >>> {target_entity.title} ga qo\'shdi. | Jami:{total_added_counter["count"]}')

user_queue.task_done()

consecutive_errors = 0

# Insoniy imitatsiya

if random.random() < PROB_HUMAN_BEHAVIOR:

await simulate_human_behavior(client, target_entity)

# Keyingisigacha kutish

await asyncio.sleep(random.uniform(MIN_SLEEP_AFTER_INVITE, MAX_SLEEP_AFTER_INVITE))

except (UserChannelsTooMuchError, UserKickedError, UserNotMutualContactError,

UserPrivacyRestrictedError, UserAlreadyParticipantError) as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Cannot add {user["name"]}: {type(e).__name__}')

user_queue.task_done()

await asyncio.sleep(random.uniform(2,5))

continue

except PeerFloodError:

print(f'{ye}[{last_two_parts}]{r}[{name}] PeerFloodError! to‘xtadi.')

user_queue.task_done()

# qayta urinish Y O‘ Q

return

except FloodWaitError as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] FloodWaitError Kutish vaqti ({e.seconds}s)! to‘xtadi.')

user_queue.task_done()

# qayta urinish Y O‘ Q (sizning siyosat)

return

except (UserBannedInChannelError, ChatWriteForbiddenError, ChatAdminRequiredError):

print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhda muammo yoki akkaunt cheklangan.')

user_queue.task_done()

return

except Exception as e:

consecutive_errors += 1

print(f'{ye}[{last_two_parts}]{r}[{name}] {user["name"]} ni qo\'shishda xato: {e}')

user_queue.task_done()

if consecutive_errors >= 4:

print(f'{ye}[{last_two_parts}]{r}[{name}] Ketma-ket xatolar ko\'p — worker to\'xtatildi.')

return

await asyncio.sleep(random.uniform(3,6))

continue

except asyncio.CancelledError:

break

# ish tugadi

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Umumiy xatolik: {e}')

finally:

try:

await client(LeaveChannelRequest(target))

print(f"{ye}[{last_two_parts}]{ye}[{name}] Guruhdan chiqdi.")

except Exception as e:

print(f"{ye}[{last_two_parts}]{r}[{name}] Guruhdan chiqishda xato: {e}")

await client.disconnect()

print(f"{ye}[{last_two_parts}]{ye}[{name}] Ishni tugatdi.")

sem_account.release()

async def main():

ensure_loop() # loop tayyor

config = configparser.ConfigParser()

config.read('../Guruxlar.ini')

# --- phone.csv ni ikkala formatda qo'llab-quvvatlash ---

phones = []

if not os.path.exists('phone.csv'):

print(f"{r}XATO: phone.csv fayli topilmadi!"); input(); return

with open('phone.csv', 'r', encoding='utf-8') as readFile:

reader = csv.reader(readFile)

for phone_ in reader:

if not phone_:

continue

raw_phone = phone_[0].strip() # masalan: '+9989...' yoki '9989...'

clean_phone = normalize_phone(raw_phone) # '9989...'

if clean_phone.isdigit():

phones.append({'raw': raw_phone, 'clean': clean_phone})

if not phones:

print(f"{r}Akkauntlar topilmadi. phone.csv faylini tekshiring."); input(); return

members = []

if not os.path.exists('users.csv'):

print(f"{r}XATO: users.csv fayli topilmadi!"); input(); return

with open('users.csv', encoding='UTF-8') as f:

rows = csv.reader(f, delimiter=",", lineterminator="\n")

next(rows, None)

for row in rows:

if len(row) >= 5:

try:

members.append({'index': row[0], 'name': row[1], 'id': int(row[2]), 'access_hash': row[3], 'status': row[4]})

except:

continue

if not members:

print(f"{r}Qo'shish uchun odamlar yo'q!"); return

total_added_counter = {'count': 0}

sem_account = asyncio.Semaphore(CONCURRENT_ACCOUNTS)

for section_name in config.sections():

TMARKET = section_name

target = config[section_name]['Qoshadigan_gurux1']

print("\n" + "="*50)

print(f"{w}Yangi jarayon: {ye}{last_two_parts}{w} | Guruh: {ye}{target}{w}")

print("="*50 + "\n")

print(f'{lg}Jami akountlar: {len(phones)}')

print(f"{lg}Qo'shish uchun odamlar: {len(members)}")

user_queue = asyncio.Queue()

for member in members:

await user_queue.put(member)

tasks = []

for phone_obj in phones:

raw = phone_obj['raw']

clean = phone_obj['clean']

# Sessiya faylini ikkala ko‘rinishda ham qidiramiz

session_plus = f'sessions/+{clean}_SQLite.session'

session_plain = f'sessions/{clean}_SQLite.session'

if os.path.exists(session_plus):

session_file = session_plus

elif os.path.exists(session_plain):

session_file = session_plain

else:

raw_based = f'sessions/{raw}_SQLite.session'

if os.path.exists(raw_based):

session_file = raw_based

else:

print(f"{r}❗ Session topilmadi: {raw} ( + bilan ham, + siz ham )")

continue

params = pony()

ensure_loop() # har bir clientdan oldin ham kafolat

client = TelegramClient(

session_file,

API_ID,

API_HASH,

device_model=params['device_model'],

system_version=params['system_version'],

app_version=params['app_version'],

lang_code=params['lang_code'],

system_lang_code=params['system_lang_code']

)

task = asyncio.create_task(

worker(f"{raw}", client, target, user_queue,

total_added_counter, last_two_parts, sem_account)

)

tasks.append(task)

try:

await asyncio.gather(*tasks)

except KeyboardInterrupt:

print(f"{r}To‘xtatildi, vazifalar bekor qilinmoqda...")

for t in tasks:

t.cancel()

await asyncio.gather(*tasks, return_exceptions=True)

message = "BARCHA ISHLAR TUGATILDI YOKI AKKOUNTLAR TOXTATILDI!!!"

terminal_width = shutil.get_terminal_size().columns

print("\n" + "\033[1;97;41m" + "!" * terminal_width + "\033[0m")

print("\033[1;32;40m" + message.center(terminal_width) + "\033[0m")

print("\033[1;97;41m" + "!" * terminal_width + "\033[0m")

print(f"\n{lg}Jami qo'shilganlar soni: {total_added_counter['count']}\n")

input("Chiqish uchun ENTER bosing...")

# === DASTUR BOSHI ===

if __name__ == '__main__':

# Windows uchun tavsiya etilgan siyosat

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

ensure_loop() # dastur startida ham

asyncio.run(main())

elif a == 2:

def filter_names_by_keywords(df_chunk, keywords):

# Конвертируем ключевые слова в верхний регистр

upper_keywords = [keyword.upper() for keyword in keywords]

# Создаем регулярное выражение для поиска ключевых слов в последних трех символах имени

regex_keywords = [re.compile(rf'\w*({re.escape(keyword)}$)', flags=re.IGNORECASE) for keyword in upper_keywords]

# Функция проверки наличия ключевых слов в последних трех символах имени

def has_keywords(name):

name_str = str(name)

for keyword in regex_keywords:

if keyword.search(name_str):

return True

return False

# Применяем функцию has_keywords к столбцу 'name' для каждой строки DataFrame

filtered_df_chunk = df_chunk[df_chunk['name'].apply(has_keywords)]

return filtered_df_chunk

def shuffle_data(df_chunk):

return df_chunk.sample(frac=1, random_state=42).reset_index(drop=True)

def evaluate_sorting(df_chunk):

total_names = len(df_chunk)

correct_names = len(df_chunk)

accuracy = (correct_names / total_names) * 100

print(f"Filter aniqlik darajasi: {accuracy:.2f}%")

if __name__ == "__main__":

input_csv_file = 'users.csv'

output_csv_file = 'ayollar.csv'

keywords = [

'ULI', 'IZA', 'DAT', 'ONU', 'HRA', 'XRA', 'ODA', 'OLA', 'ORA', 'YLO',

'XON', 'IDA', 'OVA', 'VNA', 'DUZ', 'GIM', 'UZA', 'IRA', 'NOZ', 'OZA',

'IZA', 'ARA', 'DYA', 'GUL', 'VOZ', 'XOR', 'HOR', 'IMA', 'INA', 'GIZ',

'SOZ', 'FAT', 'UBA', 'IYA', 'SAL', 'YLA', 'SHTA', 'STA', 'IBA', 'АЙЁ',

'ОДА', 'УЛЯ', 'MOR', 'ISHA', 'USHA', 'RUZ', 'УЛИ', 'ИЗА', 'ДАТ', 'ОНУ', 'ХРА', 'ХРА', 'ОДА', 'ОЛА', 'ОРА', 'ИЛО',

'ХОН', 'ИДА', 'ОВА', 'ВНА', 'ДУЗ', 'ГИМ', 'УЗА', 'ИРА', 'НОЗ', 'ОЗА',

'ИЗА', 'АРА', 'ДЯ', 'ГУЛ', 'ВОЗ', 'ХОР', 'ХОР', 'ИМА', 'ИНА', 'ГИЗ',

'СОЗ', 'ФАТ', 'УБА', 'ИЯ', 'САЛ', 'ИЛА', 'ШТА', 'СТА', 'ИБА', 'АЙЁ',

'ОДА', 'УЛЯ', 'МОР', 'ИША', 'УША', 'РУЗ'

]

chunksize = 10000

chunks = pd.read_csv(input_csv_file, chunksize=chunksize)

processed_chunks = []

for chunk in chunks:

filtered_chunk = filter_names_by_keywords(chunk, keywords)

processed_chunks.append(filtered_chunk)

processed_df = pd.concat(processed_chunks, ignore_index=True)

shuffled_df = shuffle_data(processed_df)

shuffled_df['index'] = range(1, len(shuffled_df) + 1)

shuffled_df.to_csv(output_csv_file, index=False)

evaluate_sorting(shuffled_df)

#input()

print("Ayollar ismi filterlandi va saqlandi ayollar.csv faylga")

time.sleep(2)

import os

import csv

import shutil

import configparser

import random

import asyncio

import time

from collections import deque

# Telethon: async-friendly import

from telethon import TelegramClient

from telethon.errors import (

PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,

PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,

UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,

ChatAdminRequiredError, FloodWaitError, UserKickedError, UserIdInvalidError, ChannelInvalidError

)

from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest

from telethon.tl.types import InputPeerChannel

# --- Ranglar va API sozlamalari ---

r, w, lg, ye = '\033[1;31m', '\033[1;37m', '\033[1;32m', '\033[1;33m'

API_ID = 253798

API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'

# --- Python 3.12: event loop ensure (muhim) ---

def ensure_loop():

try:

asyncio.get_running_loop()

except RuntimeError:

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

asyncio.set_event_loop(asyncio.new_event_loop())

# ====== SOZLAMALAR ======

GLOBAL_RATE_LIMIT = 50 # necha ta invite / GLOBAL_RATE_PERIOD

GLOBAL_RATE_PERIOD = 30 # sekund

CONCURRENT_ACCOUNTS = 50 # bir vaqtning o'zida nechta akkaunt

MIN_ADD_PER_ACCOUNT = 40

MAX_ADD_PER_ACCOUNT = 50

MIN_SLEEP_AFTER_INVITE = 20.0

MAX_SLEEP_AFTER_INVITE = 45.0

# Flood wait/preflood siyosati

RETRY_ON_FLOOD = False # !!! siz avval so‘ragan: Flood bo‘lsa qayta urunmasin

# ========================

# HUMAN simulation params

PROB_HUMAN_BEHAVIOR = 0.9

HUMAN_READ_MIN = 5

HUMAN_READ_MAX = 12

HUMAN_SCROLL_CHANCE = 0.6

HUMAN_SCROLL_MIN = 2

HUMAN_SCROLL_MAX = 5

# Global rate tracker

global_add_timestamps = deque()

def pony():

"""Qurilma parametrlarini random qiladi."""

devices = [

{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.2.0 (3600) arm64-v8a'},

#{'device_model': 'PC 64bit', 'system_version': 'Windows 11 24H2', 'app_version': '5.4'},

]

d = random.choice(devices)

d['system_version'] += ' | sdk 4.16.3-PYRO17'

return {

'device_model': d['device_model'],

'system_version': d['system_version'],

'app_version': d['app_version'],

'lang_code': 'en',

'system_lang_code': 'en'

}

# --- Telefon raqamlarni normalize qilish (ikkala formatni qo'llab-quvvatlash) ---

def normalize_phone(s: str) -> str:

if not s:

return ''

s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')

if s.startswith('+'):

s = s[1:]

return s

async def ensure_global_rate_slot():

"""Token-bucket uslubida umumiy tezlik cheklovi."""

while True:

now = time.time()

while global_add_timestamps and now - global_add_timestamps[0] > GLOBAL_RATE_PERIOD:

global_add_timestamps.popleft()

if len(global_add_timestamps) < GLOBAL_RATE_LIMIT:

return

wait_for = GLOBAL_RATE_PERIOD - (now - global_add_timestamps[0]) + 0.5 + random.random()

await asyncio.sleep(wait_for)

async def record_global_add():

global_add_timestamps.append(time.time())

async def simulate_human_behavior(client, target_entity):

"""Kanalni o‘qish/scroll qilishni imitatsiya qiladi (xabar yubormaydi)."""

try:

n_read = random.randint(HUMAN_READ_MIN, HUMAN_READ_MAX)

await client.get_messages(target_entity, limit=n_read)

await asyncio.sleep(random.uniform(1.2, 3.5))

if random.random() < HUMAN_SCROLL_CHANCE:

for _ in range(random.randint(1, 2)):

limit2 = random.randint(HUMAN_SCROLL_MIN, HUMAN_SCROLL_MAX)

await client.get_messages(target_entity, limit=limit2)

await asyncio.sleep(random.uniform(0.6, 2.2))

await asyncio.sleep(random.uniform(0.4, 1.8))

except Exception as e:

print(f"{ye}[HUMAN_SIM] Xatolik: {e}")

async def worker(name, client, target, user_queue, total_added_counter, last_two_parts, sem_account):

await sem_account.acquire()

try:

print(f"{ye}[{last_two_parts}]{lg}[{name}] Ishni boshladi.")

await client.connect()

if not await client.is_user_authorized():

print(f"{ye}[{last_two_parts}]{r}[{name}] Avtorizatsiya yo'q yoki raqam bloklangan!")

await client.disconnect()

return

# Guruhga join

try:

await client(JoinChannelRequest(target))

target_entity = await client.get_entity(target)

target_details = InputPeerChannel(target_entity.id, target_entity.access_hash)

except FloodWaitError as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Join paytida FloodWait: {e.seconds}s. Worker to‘xtadi.')

await client.disconnect()

return

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhga qo\'shila olmadi: {e}.')

await client.disconnect()

return

max_to_add = random.randint(MIN_ADD_PER_ACCOUNT, MAX_ADD_PER_ACCOUNT)

added_by_this_account = 0

consecutive_errors = 0

while added_by_this_account < max_to_add:

if user_queue.empty():

print(f"\n{r}[{last_two_parts}][{name}] Qo'shish uchun odamlar tugadi! Worker to‘xtatildi.\n")

break

try:

await ensure_global_rate_slot()

user = await user_queue.get()

try:

user_to_add = int(user['id'])

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Noto\'g\'ri user id: {user} — {e}')

user_queue.task_done()

await asyncio.sleep(random.uniform(1,2))

continue

try:

await client(InviteToChannelRequest(target_details, [user_to_add]))

added_by_this_account += 1

total_added_counter['count'] += 1

await record_global_add()

print(f'{ye}[{last_two_parts}]{lg}[{name}] > {user["name"]} >>> {target_entity.title} ga qo\'shdi. | Jami:{total_added_counter["count"]}')

user_queue.task_done()

consecutive_errors = 0

# Insoniy imitatsiya

if random.random() < PROB_HUMAN_BEHAVIOR:

await simulate_human_behavior(client, target_entity)

# Keyingisigacha kutish

await asyncio.sleep(random.uniform(MIN_SLEEP_AFTER_INVITE, MAX_SLEEP_AFTER_INVITE))

except (UserChannelsTooMuchError, UserKickedError, UserNotMutualContactError,

UserPrivacyRestrictedError, UserAlreadyParticipantError) as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Cannot add {user["name"]}: {type(e).__name__}')

user_queue.task_done()

await asyncio.sleep(random.uniform(2,5))

continue

except PeerFloodError:

print(f'{ye}[{last_two_parts}]{r}[{name}] PeerFloodError! to‘xtadi.')

user_queue.task_done()

# qayta urinish Y O‘ Q

return

except FloodWaitError as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] FloodWaitError Kutish vaqti ({e.seconds}s)! to‘xtadi.')

user_queue.task_done()

# qayta urinish Y O‘ Q (sizning siyosat)

return

except (UserBannedInChannelError, ChatWriteForbiddenError, ChatAdminRequiredError):

print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhda muammo yoki akkaunt cheklangan.')

user_queue.task_done()

return

except Exception as e:

consecutive_errors += 1

print(f'{ye}[{last_two_parts}]{r}[{name}] {user["name"]} ni qo\'shishda xato: {e}')

user_queue.task_done()

if consecutive_errors >= 4:

print(f'{ye}[{last_two_parts}]{r}[{name}] Ketma-ket xatolar ko\'p — worker to\'xtatildi.')

return

await asyncio.sleep(random.uniform(3,6))

continue

except asyncio.CancelledError:

break

# ish tugadi

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Umumiy xatolik: {e}')

finally:

try:

await client(LeaveChannelRequest(target))

print(f"{ye}[{last_two_parts}]{ye}[{name}] Guruhdan chiqdi.")

except Exception as e:

print(f"{ye}[{last_two_parts}]{r}[{name}] Guruhdan chiqishda xato: {e}")

await client.disconnect()

print(f"{ye}[{last_two_parts}]{ye}[{name}] Ishni tugatdi.")

sem_account.release()

async def main():

ensure_loop() # loop tayyor

config = configparser.ConfigParser()

config.read('../Guruxlar.ini')

# --- phone.csv ni ikkala formatda qo'llab-quvvatlash ---

phones = []

if not os.path.exists('phone.csv'):

print(f"{r}XATO: phone.csv fayli topilmadi!"); input(); return

with open('phone.csv', 'r', encoding='utf-8') as readFile:

reader = csv.reader(readFile)

for phone_ in reader:

if not phone_:

continue

raw_phone = phone_[0].strip() # masalan: '+9989...' yoki '9989...'

clean_phone = normalize_phone(raw_phone) # '9989...'

if clean_phone.isdigit():

phones.append({'raw': raw_phone, 'clean': clean_phone})

if not phones:

print(f"{r}Akkauntlar topilmadi. phone.csv faylini tekshiring."); input(); return

members = []

if not os.path.exists('ayollar.csv'):

print(f"{r}XATO: ayollar.csv fayli topilmadi!"); input(); return

with open('ayollar.csv', encoding='UTF-8') as f:

rows = csv.reader(f, delimiter=",", lineterminator="\n")

next(rows, None)

for row in rows:

if len(row) >= 5:

try:

members.append({'index': row[0], 'name': row[1], 'id': int(row[2]), 'access_hash': row[3], 'status': row[4]})

except:

continue

if not members:

print(f"{r}Qo'shish uchun odamlar yo'q!"); return

total_added_counter = {'count': 0}

sem_account = asyncio.Semaphore(CONCURRENT_ACCOUNTS)

for section_name in config.sections():

TMARKET = section_name

target = config[section_name]['Qoshadigan_gurux1']

print("\n" + "="*50)

print(f"{w}Yangi jarayon: {ye}{last_two_parts}{w} | Guruh: {ye}{target}{w}")

print("="*50 + "\n")

print(f'{lg}Jami akountlar: {len(phones)}')

print(f"{lg}Qo'shish uchun odamlar: {len(members)}")

user_queue = asyncio.Queue()

for member in members:

await user_queue.put(member)

tasks = []

for phone_obj in phones:

raw = phone_obj['raw']

clean = phone_obj['clean']

# Sessiya faylini ikkala ko‘rinishda ham qidiramiz

session_plus = f'sessions/+{clean}_SQLite.session'

session_plain = f'sessions/{clean}_SQLite.session'

if os.path.exists(session_plus):

session_file = session_plus

elif os.path.exists(session_plain):

session_file = session_plain

else:

raw_based = f'sessions/{raw}_SQLite.session'

if os.path.exists(raw_based):

session_file = raw_based

else:

print(f"{r}❗ Session topilmadi: {raw} ( + bilan ham, + siz ham )")

continue

params = pony()

ensure_loop() # har bir clientdan oldin ham kafolat

client = TelegramClient(

session_file,

API_ID,

API_HASH,

device_model=params['device_model'],

system_version=params['system_version'],

app_version=params['app_version'],

lang_code=params['lang_code'],

system_lang_code=params['system_lang_code']

)

task = asyncio.create_task(

worker(f"{raw}", client, target, user_queue,

total_added_counter, last_two_parts, sem_account)

)

tasks.append(task)

try:

await asyncio.gather(*tasks)

except KeyboardInterrupt:

print(f"{r}To‘xtatildi, vazifalar bekor qilinmoqda...")

for t in tasks:

t.cancel()

await asyncio.gather(*tasks, return_exceptions=True)

message = "BARCHA ISHLAR TUGATILDI YOKI AKKOUNTLAR TOXTATILDI!!!"

terminal_width = shutil.get_terminal_size().columns

print("\n" + "\033[1;97;41m" + "!" * terminal_width + "\033[0m")

print("\033[1;32;40m" + message.center(terminal_width) + "\033[0m")

print("\033[1;97;41m" + "!" * terminal_width + "\033[0m")

print(f"\n{lg}Jami qo'shilganlar soni: {total_added_counter['count']}\n")

input("Chiqish uchun ENTER bosing...")

# === DASTUR BOSHI ===

if __name__ == '__main__':

# Windows uchun tavsiya etilgan siyosat

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

ensure_loop() # dastur startida ham

asyncio.run(main())

elif a == 3:

def filter_names_by_keywords(df_chunk, keywords):

# Конвертируем ключевые слова в верхний регистр

upper_keywords = [keyword.upper() for keyword in keywords]

# Создаем регулярное выражение для поиска ключевых слов в последних трех символах имени

regex_keywords = [re.compile(rf'\w*({re.escape(keyword)}$)', flags=re.IGNORECASE) for keyword in upper_keywords]

# Функция проверки наличия ключевых слов в последних трех символах имени

def has_keywords(name):

name_str = str(name)

for keyword in regex_keywords:

if keyword.search(name_str):

return True

return False

# Применяем функцию has_keywords к столбцу 'name' для каждой строки DataFrame

filtered_df_chunk = df_chunk[df_chunk['name'].apply(has_keywords)]

return filtered_df_chunk

def shuffle_data(df_chunk):

return df_chunk.sample(frac=1, random_state=42).reset_index(drop=True)

def evaluate_sorting(df_chunk):

total_names = len(df_chunk)

correct_names = len(df_chunk)

accuracy = (correct_names / total_names) * 100

print(f"Filter aniqlik darajasi: {accuracy:.2f}%")

if __name__ == "__main__":

input_csv_file = 'users.csv'

output_csv_file = 'erkaklar.csv'

keywords = [

'BEK', 'JON', 'XOM', 'VAR', 'SHOD', 'XID', 'TON', 'LIK', 'GIR', 'ZIZ',

'KIN', 'MAL', 'SIM', 'LLO', 'LIM', 'YOR', 'QAT', 'BOZ', 'YOT', 'RUR',

'SUR', 'XIR', 'VAZ', 'XOD', 'MID', 'RAT', 'KIR', 'MUR', 'ROB', 'ALI',

'SHER', 'GOR', 'AID', 'ROD', 'SUD', 'BOL', 'DOR', 'TAM', 'DIR', 'SHID',

'JAR', 'SIN', 'BOY', 'DIN', 'KAL', 'RUF', 'IZO', 'MOV', 'AFO', 'БЕК', 'ДЖОН', 'ХОМ', 'ВАР', 'ШОД', 'ХИД', 'ТОН', 'ЛИК', 'ГИР', 'ЗИЗ',

'КИН', 'МАЛ', 'СИМ', 'ЛЛО', 'ЛИМ', 'ЁР', 'КАТ', 'БОЗ', 'ЁТ', 'РУР',

'СУР', 'ХИР', 'ВАЗ', 'ХОД', 'МИД', 'РАТ', 'КИР', 'МУР', 'РОБ', 'АЛИ',

'ШЕР', 'ГОР', 'АЙД', 'РОД', 'СУД', 'БОЛ', 'ДОР', 'ТАМ', 'ДИР', 'ШИД',

'ДЖАР', 'СИН', 'БОЙ', 'ДИН', 'КАЛ', 'РУФ', 'ИЗО', 'МОВ', 'АФО'

]

chunksize = 10000

chunks = pd.read_csv(input_csv_file, chunksize=chunksize)

processed_chunks = []

for chunk in chunks:

filtered_chunk = filter_names_by_keywords(chunk, keywords)

processed_chunks.append(filtered_chunk)

processed_df = pd.concat(processed_chunks, ignore_index=True)

shuffled_df = shuffle_data(processed_df)

shuffled_df['index'] = range(1, len(shuffled_df) + 1)

shuffled_df.to_csv(output_csv_file, index=False)

evaluate_sorting(shuffled_df)

#input()

print("Erkaklar ismi filterlandi va saqlandi erkaklar.csv faylga")

time.sleep(2)

import os

import csv

import shutil

import configparser

import random

import asyncio

import time

from collections import deque

# Telethon: async-friendly import

from telethon import TelegramClient

from telethon.errors import (

PhoneNumberBannedError, SessionPasswordNeededError, UserPrivacyRestrictedError,

PeerFloodError, UserChannelsTooMuchError, UserNotMutualContactError,

UserAlreadyParticipantError, ChatWriteForbiddenError, UserBannedInChannelError,

ChatAdminRequiredError, FloodWaitError, UserKickedError, UserIdInvalidError, ChannelInvalidError

)

from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest, LeaveChannelRequest

from telethon.tl.types import InputPeerChannel

# --- Ranglar va API sozlamalari ---

r, w, lg, ye = '\033[1;31m', '\033[1;37m', '\033[1;32m', '\033[1;33m'

API_ID = 253798

API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'

# --- Python 3.12: event loop ensure (muhim) ---

def ensure_loop():

try:

asyncio.get_running_loop()

except RuntimeError:

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

asyncio.set_event_loop(asyncio.new_event_loop())

# ====== SOZLAMALAR ======

GLOBAL_RATE_LIMIT = 50 # necha ta invite / GLOBAL_RATE_PERIOD

GLOBAL_RATE_PERIOD = 30 # sekund

CONCURRENT_ACCOUNTS = 50 # bir vaqtning o'zida nechta akkaunt

MIN_ADD_PER_ACCOUNT = 40

MAX_ADD_PER_ACCOUNT = 50

MIN_SLEEP_AFTER_INVITE = 20.0

MAX_SLEEP_AFTER_INVITE = 45.0

# Flood wait/preflood siyosati

RETRY_ON_FLOOD = False # !!! siz avval so‘ragan: Flood bo‘lsa qayta urunmasin

# ========================

# HUMAN simulation params

PROB_HUMAN_BEHAVIOR = 0.9

HUMAN_READ_MIN = 5

HUMAN_READ_MAX = 12

HUMAN_SCROLL_CHANCE = 0.6

HUMAN_SCROLL_MIN = 2

HUMAN_SCROLL_MAX = 5

# Global rate tracker

global_add_timestamps = deque()

def pony():

"""Qurilma parametrlarini random qiladi."""

devices = [

{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Samsung SM-A556B (Galaxy A55)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.2.0 (3600) arm64-v8a'},

{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.2', 'app_version': '11.2.0 (3600) arm64-v8a'},

#{'device_model': 'PC 64bit', 'system_version': 'Windows 11 24H2', 'app_version': '5.4'},

]

d = random.choice(devices)

d['system_version'] += ' | sdk 4.16.3-PYRO17'

return {

'device_model': d['device_model'],

'system_version': d['system_version'],

'app_version': d['app_version'],

'lang_code': 'en',

'system_lang_code': 'en'

}

# --- Telefon raqamlarni normalize qilish (ikkala formatni qo'llab-quvvatlash) ---

def normalize_phone(s: str) -> str:

if not s:

return ''

s = s.strip().replace(' ', '').replace('-', '').replace('(', '').replace(')', '')

if s.startswith('+'):

s = s[1:]

return s

async def ensure_global_rate_slot():

"""Token-bucket uslubida umumiy tezlik cheklovi."""

while True:

now = time.time()

while global_add_timestamps and now - global_add_timestamps[0] > GLOBAL_RATE_PERIOD:

global_add_timestamps.popleft()

if len(global_add_timestamps) < GLOBAL_RATE_LIMIT:

return

wait_for = GLOBAL_RATE_PERIOD - (now - global_add_timestamps[0]) + 0.5 + random.random()

await asyncio.sleep(wait_for)

async def record_global_add():

global_add_timestamps.append(time.time())

async def simulate_human_behavior(client, target_entity):

"""Kanalni o‘qish/scroll qilishni imitatsiya qiladi (xabar yubormaydi)."""

try:

n_read = random.randint(HUMAN_READ_MIN, HUMAN_READ_MAX)

await client.get_messages(target_entity, limit=n_read)

await asyncio.sleep(random.uniform(1.2, 3.5))

if random.random() < HUMAN_SCROLL_CHANCE:

for _ in range(random.randint(1, 2)):

limit2 = random.randint(HUMAN_SCROLL_MIN, HUMAN_SCROLL_MAX)

await client.get_messages(target_entity, limit=limit2)

await asyncio.sleep(random.uniform(0.6, 2.2))

await asyncio.sleep(random.uniform(0.4, 1.8))

except Exception as e:

print(f"{ye}[HUMAN_SIM] Xatolik: {e}")

async def worker(name, client, target, user_queue, total_added_counter, last_two_parts, sem_account):

await sem_account.acquire()

try:

print(f"{ye}[{last_two_parts}]{lg}[{name}] Ishni boshladi.")

await client.connect()

if not await client.is_user_authorized():

print(f"{ye}[{last_two_parts}]{r}[{name}] Avtorizatsiya yo'q yoki raqam bloklangan!")

await client.disconnect()

return

# Guruhga join

try:

await client(JoinChannelRequest(target))

target_entity = await client.get_entity(target)

target_details = InputPeerChannel(target_entity.id, target_entity.access_hash)

except FloodWaitError as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Join paytida FloodWait: {e.seconds}s. Worker to‘xtadi.')

await client.disconnect()

return

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhga qo\'shila olmadi: {e}.')

await client.disconnect()

return

max_to_add = random.randint(MIN_ADD_PER_ACCOUNT, MAX_ADD_PER_ACCOUNT)

added_by_this_account = 0

consecutive_errors = 0

while added_by_this_account < max_to_add:

if user_queue.empty():

print(f"\n{r}[{last_two_parts}][{name}] Qo'shish uchun odamlar tugadi! Worker to‘xtatildi.\n")

break

try:

await ensure_global_rate_slot()

user = await user_queue.get()

try:

user_to_add = int(user['id'])

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Noto\'g\'ri user id: {user} — {e}')

user_queue.task_done()

await asyncio.sleep(random.uniform(1,2))

continue

try:

await client(InviteToChannelRequest(target_details, [user_to_add]))

added_by_this_account += 1

total_added_counter['count'] += 1

await record_global_add()

print(f'{ye}[{last_two_parts}]{lg}[{name}] > {user["name"]} >>> {target_entity.title} ga qo\'shdi. | Jami:{total_added_counter["count"]}')

user_queue.task_done()

consecutive_errors = 0

# Insoniy imitatsiya

if random.random() < PROB_HUMAN_BEHAVIOR:

await simulate_human_behavior(client, target_entity)

# Keyingisigacha kutish

await asyncio.sleep(random.uniform(MIN_SLEEP_AFTER_INVITE, MAX_SLEEP_AFTER_INVITE))

except (UserChannelsTooMuchError, UserKickedError, UserNotMutualContactError,

UserPrivacyRestrictedError, UserAlreadyParticipantError) as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Cannot add {user["name"]}: {type(e).__name__}')

user_queue.task_done()

await asyncio.sleep(random.uniform(2,5))

continue

except PeerFloodError:

print(f'{ye}[{last_two_parts}]{r}[{name}] PeerFloodError! to‘xtadi.')

user_queue.task_done()

# qayta urinish Y O‘ Q

return

except FloodWaitError as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] FloodWaitError Kutish vaqti ({e.seconds}s)! to‘xtadi.')

user_queue.task_done()

# qayta urinish Y O‘ Q (sizning siyosat)

return

except (UserBannedInChannelError, ChatWriteForbiddenError, ChatAdminRequiredError):

print(f'{ye}[{last_two_parts}]{r}[{name}] Guruhda muammo yoki akkaunt cheklangan.')

user_queue.task_done()

return

except Exception as e:

consecutive_errors += 1

print(f'{ye}[{last_two_parts}]{r}[{name}] {user["name"]} ni qo\'shishda xato: {e}')

user_queue.task_done()

if consecutive_errors >= 4:

print(f'{ye}[{last_two_parts}]{r}[{name}] Ketma-ket xatolar ko\'p — worker to\'xtatildi.')

return

await asyncio.sleep(random.uniform(3,6))

continue

except asyncio.CancelledError:

break

# ish tugadi

except Exception as e:

print(f'{ye}[{last_two_parts}]{r}[{name}] Umumiy xatolik: {e}')

finally:

try:

await client(LeaveChannelRequest(target))

print(f"{ye}[{last_two_parts}]{ye}[{name}] Guruhdan chiqdi.")

except Exception as e:

print(f"{ye}[{last_two_parts}]{r}[{name}] Guruhdan chiqishda xato: {e}")

await client.disconnect()

print(f"{ye}[{last_two_parts}]{ye}[{name}] Ishni tugatdi.")

sem_account.release()

async def main():

ensure_loop() # loop tayyor

config = configparser.ConfigParser()

config.read('../Guruxlar.ini')

# --- phone.csv ni ikkala formatda qo'llab-quvvatlash ---

phones = []

if not os.path.exists('phone.csv'):

print(f"{r}XATO: phone.csv fayli topilmadi!"); input(); return

with open('phone.csv', 'r', encoding='utf-8') as readFile:

reader = csv.reader(readFile)

for phone_ in reader:

if not phone_:

continue

raw_phone = phone_[0].strip() # masalan: '+9989...' yoki '9989...'

clean_phone = normalize_phone(raw_phone) # '9989...'

if clean_phone.isdigit():

phones.append({'raw': raw_phone, 'clean': clean_phone})

if not phones:

print(f"{r}Akkauntlar topilmadi. phone.csv faylini tekshiring."); input(); return

members = []

if not os.path.exists('erkaklar.csv'):

print(f"{r}XATO: erkaklar.csv fayli topilmadi!"); input(); return

with open('erkaklar.csv', encoding='UTF-8') as f:

rows = csv.reader(f, delimiter=",", lineterminator="\n")

next(rows, None)

for row in rows:

if len(row) >= 5:

try:

members.append({'index': row[0], 'name': row[1], 'id': int(row[2]), 'access_hash': row[3], 'status': row[4]})

except:

continue

if not members:

print(f"{r}Qo'shish uchun odamlar yo'q!"); return

total_added_counter = {'count': 0}

sem_account = asyncio.Semaphore(CONCURRENT_ACCOUNTS)

for section_name in config.sections():

TMARKET = section_name

target = config[section_name]['Qoshadigan_gurux1']

print("\n" + "="*50)

print(f"{w}Yangi jarayon: {ye}{last_two_parts}{w} | Guruh: {ye}{target}{w}")

print("="*50 + "\n")

print(f'{lg}Jami akountlar: {len(phones)}')

print(f"{lg}Qo'shish uchun odamlar: {len(members)}")

user_queue = asyncio.Queue()

for member in members:

await user_queue.put(member)

tasks = []

for phone_obj in phones:

raw = phone_obj['raw']

clean = phone_obj['clean']

# Sessiya faylini ikkala ko‘rinishda ham qidiramiz

session_plus = f'sessions/+{clean}_SQLite.session'

session_plain = f'sessions/{clean}_SQLite.session'

if os.path.exists(session_plus):

session_file = session_plus

elif os.path.exists(session_plain):

session_file = session_plain

else:

raw_based = f'sessions/{raw}_SQLite.session'

if os.path.exists(raw_based):

session_file = raw_based

else:

print(f"{r}❗ Session topilmadi: {raw} ( + bilan ham, + siz ham )")

continue

params = pony()

ensure_loop() # har bir clientdan oldin ham kafolat

client = TelegramClient(

session_file,

API_ID,

API_HASH,

device_model=params['device_model'],

system_version=params['system_version'],

app_version=params['app_version'],

lang_code=params['lang_code'],

system_lang_code=params['system_lang_code']

)

task = asyncio.create_task(

worker(f"{raw}", client, target, user_queue,

total_added_counter, last_two_parts, sem_account)

)

tasks.append(task)

try:

await asyncio.gather(*tasks)

except KeyboardInterrupt:

print(f"{r}To‘xtatildi, vazifalar bekor qilinmoqda...")

for t in tasks:

t.cancel()

await asyncio.gather(*tasks, return_exceptions=True)

message = "BARCHA ISHLAR TUGATILDI YOKI AKKOUNTLAR TOXTATILDI!!!"

terminal_width = shutil.get_terminal_size().columns

print("\n" + "\033[1;97;41m" + "!" * terminal_width + "\033[0m")

print("\033[1;32;40m" + message.center(terminal_width) + "\033[0m")

print("\033[1;97;41m" + "!" * terminal_width + "\033[0m")

print(f"\n{lg}Jami qo'shilganlar soni: {total_added_counter['count']}\n")

input("Chiqish uchun ENTER bosing...")

# === DASTUR BOSHI ===

if __name__ == '__main__':

# Windows uchun tavsiya etilgan siyosat

if os.name == 'nt':

try:

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

except Exception:

pass

ensure_loop() # dastur startida ham

asyncio.run(main())

elif a == 4:

import os

import csv

import random

import asyncio

import ctypes

from telethon import TelegramClient

from telethon.sessions import StringSession

from telethon.errors import (

SessionPasswordNeededError,

PasswordHashInvalidError,

PhoneCodeInvalidError,

PhoneCodeExpiredError,

PhoneNumberBannedError,

)

API_ID = 253798

API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'

SESSION_FOLDER = './sessions'

# ---------- RANGLARNI YOQISH (Windows uchun VT100) ----------

def _enable_ansi_on_windows():

if os.name != 'nt':

return

try:

kernel32 = ctypes.windll.kernel32

h = kernel32.GetStdHandle(-11) # STD_OUTPUT_HANDLE = -11

mode = ctypes.c_uint32()

if kernel32.GetConsoleMode(h, ctypes.byref(mode)):

ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004

kernel32.SetConsoleMode(h, mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)

except Exception:

pass

_enable_ansi_on_windows()

# ANSI ranglar

CLR = {

'reset' : '\033[0m',

'bold' : '\033[1m',

'red' : '\033[31m',

'green' : '\033[32m',

'yellow' : '\033[33m',

'blue' : '\033[34m',

'magenta': '\033[35m',

'cyan' : '\033[36m',

'white' : '\033[37m',

'bwhite' : '\033[97m',

}

DEVICE_COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'bwhite']

def colorize(text: str, color: str, bold: bool = False) -> str:

c = CLR.get(color, '')

b = CLR['bold'] if bold else ''

r = CLR['reset']

return f"{b}{c}{text}{r}"

def pick_color_for_device(model: str) -> str:

idx = abs(hash(model)) % len(DEVICE_COLORS)

return DEVICE_COLORS[idx]

def platform_emoji(model: str, system_version: str) -> str:

m = (model or '').lower()

s = (system_version or '').lower()

if 'pc' in m or 'windows' in s:

return '🖥️'

if 'harmony' in s or 'huawei' in m:

return '🌌'

return '🤖'

# === CSV o‘qish ===

def read_phones_from_csv(file_path):

phone_numbers = []

if not os.path.exists(file_path):

print(colorize(f"XATO: {file_path} fayli topilmadi!", 'red', True))

return []

with open(file_path, newline='', encoding='utf-8') as csvfile:

reader = csv.reader(csvfile)

for row in reader:

if row and row[0].strip():

phone_numbers.append(row[0].strip())

return phone_numbers

# === REAL RANDOM DEVICE LIST (2025) ===

RANDOM_DEVICES = [

{'device_model': 'Samsung SM-S928B (Galaxy S24 Ultra)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.0.0 (3500) arm64-v8a'},

{'device_model': 'Xiaomi 14 (23127PN0CG)', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.0.0 (3500) arm64-v8a'},

{'device_model': 'OnePlus 12', 'system_version': 'Android 14 (SDK 34)', 'app_version': '11.0.0 (3500) arm64-v8a'},

{'device_model': 'Google Pixel 9 Pro', 'system_version': 'Android 15 (SDK 35)', 'app_version': '11.0.0 (3500) arm64-v8a'},

{'device_model': 'Huawei P60 Pro', 'system_version': 'HarmonyOS 4.0', 'app_version': '11.0.0 (3500) arm64-v8a'},

]

def random_device_params():

d = random.choice(RANDOM_DEVICES)

system_ver = f"{d['system_version']} | sdk 4.16.3-PYRO17"

return {

'device_model': d['device_model'],

'system_version': system_ver,

'app_version': d['app_version'],

'lang_code': 'en',

'system_lang_code': 'en'

}

# === TELETHON SESSION CREATOR (majburiy yangi qurilma bilan) ===

async def create_and_check_session(phone):

session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone}.session')

# Har safar yangi qurilma

device_params = random_device_params()

dev_color = pick_color_for_device(device_params['device_model'])

icon = platform_emoji(device_params['device_model'], device_params['system_version'])

device_line = f"{icon} {device_params['device_model']} | {device_params['system_version']} | app {device_params['app_version']}"

print(colorize(f"\nStart {phone}", 'cyan', True))

print(colorize(f"Qurilma tanlandi → {device_line}", dev_color, True))

# Hatto mavjud sessiyada ham yangi qurilma parametrlari o‘rnatiladi

if os.path.exists(session_file):

with open(session_file, 'r', encoding='utf-8') as f:

session_string = f.read().strip()

client = TelegramClient(StringSession(session_string), API_ID, API_HASH, **device_params)

# 👇 majburan yangi device parametrlarini yozamiz

client._flood_sleep_threshold = 5

client._device_model = device_params['device_model']

client._system_version = device_params['system_version']

client._app_version = device_params['app_version']

client._lang_code = device_params['lang_code']

client._system_lang_code = device_params['system_lang_code']

else:

client = TelegramClient(StringSession(), API_ID, API_HASH, **device_params)

try:

await client.connect()

if await client.is_user_authorized():

me = await client.get_me()

print(colorize(f"✅ Tasdiqlandi (sessiya mavjud): {phone} | {getattr(me, 'first_name', '')}", 'green', True))

# Har safar sessiyani yangilaymiz

session_string = client.session.save()

with open(session_file, 'w', encoding='utf-8') as f:

f.write(session_string)

return phone

await client.send_code_request(phone)

attempts_left = 3

while True:

code = input(colorize(f'{phone} Kodni kiriting: ', 'yellow', True)).strip()

if not code:

print(colorize("Kod bo'sh bo'lmasin.", 'red', True))

continue

try:

await client.sign_in(phone, code)

break

except SessionPasswordNeededError:

while True:

password = input(colorize(f'{phone} 2FA parolni kiriting: ', 'yellow', True))

try:

await client.sign_in(password=password)

break

except PasswordHashInvalidError:

print(colorize("Parol xato. Qayta kiriting!", 'red', True))

continue

break

except PhoneCodeInvalidError:

attempts_left -= 1

print(colorize(f"Kod xato. Qayta kiriting! (qolgan urinishlar: {attempts_left})", 'red', True))

if attempts_left == 0:

print(colorize("Urinishlar tugadi. Yangi kod so'ralmoqda...", 'yellow', True))

await client.send_code_request(phone)

attempts_left = 3

except PhoneCodeExpiredError:

print(colorize("Kodning amal qilish muddati tugagan. Yangi kod so'ralmoqda...", 'yellow', True))

await client.send_code_request(phone)

attempts_left = 3

except PhoneNumberBannedError:

print(colorize(f"{phone} raqami BAN qilingan.", 'red', True))

return None

except Exception as e:

print(colorize(f"Noma'lum xato: {e}", 'red', True))

return None

if await client.is_user_authorized():

me = await client.get_me()

print(colorize(f"🎉 Muvaffaqiyatli avtorizatsiya: {phone} | {getattr(me, 'first_name', '')}", 'green', True))

session_string = client.session.save()

with open(session_file, 'w', encoding='utf-8') as f:

f.write(session_string)

return phone

else:

print(colorize(f"{phone} avtorizatsiyadan o'tkazilmadi.", 'red', True))

return None

except Exception as e:

print(colorize(f"Umumiy xatolik {phone}: {str(e)}", 'red', True))

return None

finally:

if client.is_connected():

await client.disconnect()

# === STRING → SQLITE migratsiya ===

async def migrate_string_to_sqlite(phone_number):

session_file = os.path.join(SESSION_FOLDER, f'telethon_{phone_number}.session')

if not os.path.exists(session_file):

print(colorize(f"SESSIYA {phone_number} TOPILMADI.", 'red', True))

return

with open(session_file, 'r', encoding='utf-8') as f:

session_string = f.read().strip()

client = TelegramClient(StringSession(session_string), API_ID, API_HASH)

async with client:

await client.connect()

dc_id, server_address, port = client.session.dc_id, client.session.server_address, client.session.port

auth_key = client.session.auth_key

sqlite_session_file = os.path.join(SESSION_FOLDER, f'{phone_number}_SQLite.session')

sqlite_client = TelegramClient(sqlite_session_file, API_ID, API_HASH)

await sqlite_client.connect()

sqlite_client.session.set_dc(dc_id, server_address, port)

sqlite_client.session.auth_key = auth_key

sqlite_client.session.save()

await sqlite_client.disconnect()

print(colorize(f"🧳 Migratsiya {phone_number} → SQLite session... OK", 'magenta', True))

# === MAIN ===

async def main():

if not os.path.exists(SESSION_FOLDER):

os.makedirs(SESSION_FOLDER)

phone_numbers = read_phones_from_csv('phone.csv')

if not phone_numbers:

input(colorize("phone.csv bo'sh yoki topilmadi. Chiqish uchun ENTER bosing.", 'yellow', True))

return

authorized_phones = []

for phone in phone_numbers:

result = await create_and_check_session(phone)

if result:

authorized_phones.append(result)

if authorized_phones:

print(colorize("\n--- Migratsiya jarayoni boshlandi ---", 'bwhite', True))

migration_tasks = [migrate_string_to_sqlite(phone) for phone in authorized_phones]

await asyncio.gather(*migration_tasks)

print(colorize('\nTelefonlar ro\'yxatdan o\'tkazildi va migratsiya qilindi!\n', 'cyan', True))

input(colorize("ENTER chiqish", 'yellow', True))

if __name__ == "__main__":

if os.name == 'nt':

asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

asyncio.run(main())

elif a == 5:

import os

import csv

import random

import requests

import asyncio

from telethon import TelegramClient

from telethon.errors import RPCError

from telethon.sessions import StringSession

from telethon.tl.functions.photos import UploadProfilePhotoRequest

API_ID = 253798

API_HASH = 'd806c9ed3eb74a233d58cb4a072a68f0'

# --- YANGI: realistik random qurilmalar (2024–2025) ---

RANDOM_DEVICES = [

# Android / HarmonyOS